/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package jsonutils

import (
        "encoding/json"
        "fmt"
        "io"
        "strings"
)

// JSONStreamWriter writes tokens as parsed by a json.Decoder back to a string
type JSONStreamWriter struct {
        // out is the output destination
        out io.Writer

        // indent is the current indent level
        indent string

        // state stores a stack of the json state, comprised of [ { and F characters.  F=field
        state string

        // deferred is used to buffer the output temporarily, used to prevent a trailing comma in an object
        deferred string

        // path is the current stack of fields, used to support the Path() function
        path []string
}

// NewJSONStreamWriter is the constructor for a JSONStreamWriter
func NewJSONStreamWriter(out io.Writer) *JSONStreamWriter {
        return &JSONStreamWriter{
                out: out,
        }
}

// Path returns the path to the current position in the JSON tree
func (j *JSONStreamWriter) Path() string {
        return strings.Join(j.path, ".")
}

// WriteToken writes the next token to the output
func (j *JSONStreamWriter) WriteToken(token json.Token) error {
        state := byte(0)
        if j.state != "" {
                state = j.state[len(j.state)-1]
        }

        var v string
        switch tt := token.(type) {
        //        Delim, for the four JSON delimiters [ ] { }
        case json.Delim:
                v = tt.String()
                indent := j.indent
                switch tt {
                case json.Delim('{'):
                        j.indent += "  "
                        j.state += "{"
                case json.Delim('['):
                        j.indent += "  "
                        j.state += "["
                case json.Delim(']'), json.Delim('}'):
                        j.indent = j.indent[:len(j.indent)-2]
                        indent = j.indent
                        j.state = j.state[:len(j.state)-1]
                        if j.state != "" && j.state[len(j.state)-1] == 'F' {
                                j.state = j.state[:len(j.state)-1]
                                j.path = j.path[:len(j.path)-1]
                        }
                        // Don't put a comma on the last field in a block
                        if j.deferred == ",\n" {
                                j.deferred = "\n"
                        }
                default:
                        return fmt.Errorf("unknown delim: %v", tt)
                }

                switch state {
                case 0:
                        if err := j.writeRaw(indent + v); err != nil {
                                return err
                        }
                case '{':
                        if err := j.writeRaw(indent + v); err != nil {
                                return err
                        }
                case '[':
                        if err := j.writeRaw(indent + v); err != nil {
                                return err
                        }
                case 'F':
                        if err := j.writeRaw(v); err != nil {
                                return err
                        }

                default:
                        return fmt.Errorf("unhandled state for json delim serialization: %v %q", state, j.state)
                }

                switch tt {
                case json.Delim('{'):
                        j.deferred = "\n"
                case json.Delim('['):
                        j.deferred = "\n"
                case json.Delim(']'), json.Delim('}'):
                        j.deferred = ",\n"
                default:
                        return fmt.Errorf("unknown delim: %v", tt)
                }

                return nil

                //                bool, for JSON booleans
        case bool:
                v = fmt.Sprintf("%v", tt)

                //        string, for JSON string literals
        case string:
                v = "\"" + tt + "\""

                //        float64, for JSON numbers
        case float64:
                v = fmt.Sprintf("%g", tt)

                //        Number, for JSON numbers
        case json.Number:
                v = tt.String()

                //        nil, for JSON null
        case nil:
                v = "null"

        default:
                return fmt.Errorf("unhandled token type %T", tt)
        }

        switch state {
        case '{':
                j.state += "F"
                j.path = append(j.path, fmt.Sprintf("%s", token))
                return j.writeRaw(j.indent + v + ": ")
        case '[':
                if err := j.writeRaw(j.indent + v); err != nil {
                        return err
                }
                j.deferred = ",\n"
                return nil
        case 'F':
                j.state = j.state[:len(j.state)-1]
                j.path = j.path[:len(j.path)-1]
                if err := j.writeRaw(v); err != nil {
                        return err
                }
                j.deferred = ",\n"
                return nil
        }

        return fmt.Errorf("unhandled state for json value (%T %q) serialization: %v %q", token, v, state, j.state)
}

func (j *JSONStreamWriter) writeRaw(s string) error {
        if j.deferred != "" {
                if _, err := j.out.Write([]byte(j.deferred)); err != nil {
                        return err
                }
                j.deferred = ""
        }
        _, err := j.out.Write([]byte(s))
        return err
}

/*
Copyright 2024 The Kubernetes Authors.

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.
*/

package jsonutils

import (
        "encoding/json"
        "fmt"
        "sort"
)

// Transformer is used to transform JSON values
type Transformer struct {
        stringTransforms []func(path string, value string) (string, error)
        objectTransforms []func(path string, value map[string]any) error
        sliceTransforms  []func(path string, value []any) ([]any, error)
}

// NewTransformer is the constructor for a Transformer
func NewTransformer() *Transformer {
        return &Transformer{}
}

// AddStringTransform adds a function that will be called for each string value in the JSON tree
func (t *Transformer) AddStringTransform(fn func(path string, value string) (string, error)) {
        t.stringTransforms = append(t.stringTransforms, fn)
}

// AddObjectTransform adds a function that will be called for each object in the JSON tree
func (t *Transformer) AddObjectTransform(fn func(path string, value map[string]any) error) {
        t.objectTransforms = append(t.objectTransforms, fn)
}

// AddSliceTransform adds a function that will be called for each slice in the JSON tree
func (t *Transformer) AddSliceTransform(fn func(path string, value []any) ([]any, error)) {
        t.sliceTransforms = append(t.sliceTransforms, fn)
}

// Transform applies the transformations to the JSON tree
func (o *Transformer) Transform(v map[string]any) error {
        _, err := o.visitAny(v, "")
        return err
}

// visitAny is a helper function that visits any value in the JSON tree
func (o *Transformer) visitAny(v any, path string) (any, error) {
        if v == nil {
                return v, nil
        }
        switch v := v.(type) {
        case map[string]any:
                if err := o.visitMap(v, path); err != nil {
                        return nil, err
                }
                return v, nil
        case []any:
                return o.visitSlice(v, path)
        case int64, float64, bool:
                return o.visitPrimitive(v, path)
        case string:
                return o.visitString(v, path)
        default:
                return nil, fmt.Errorf("unhandled type at path %q: %T", path, v)
        }
}

func (o *Transformer) visitMap(m map[string]any, path string) error {
        for _, fn := range o.objectTransforms {
                if err := fn(path, m); err != nil {
                        return err
                }
        }

        for k, v := range m {
                childPath := path + "." + k

                v2, err := o.visitAny(v, childPath)
                if err != nil {
                        return err
                }
                m[k] = v2
        }

        return nil
}

// visitSlice is a helper function that visits a slice in the JSON tree
func (o *Transformer) visitSlice(s []any, path string) (any, error) {
        for _, fn := range o.sliceTransforms {
                var err error
                s, err = fn(path+"[]", s)
                if err != nil {
                        return nil, err
                }
        }

        for i, v := range s {
                v2, err := o.visitAny(v, path+"[]")
                if err != nil {
                        return nil, err
                }
                s[i] = v2
        }

        return s, nil
}

// SortSlice sorts a slice of any values, ordered by their JSON representations.
// This is not very efficient, but is convenient for small slice where we don't know their types.
func SortSlice(s []any) ([]any, error) {
        type entry struct {
                o       any
                sortKey string
        }

        var entries []entry
        for i := range s {
                j, err := json.Marshal(s[i])
                if err != nil {
                        return nil, fmt.Errorf("error converting to json: %w", err)
                }
                entries = append(entries, entry{o: s[i], sortKey: string(j)})
        }

        sort.Slice(entries, func(i, j int) bool {
                return entries[i].sortKey < entries[j].sortKey
        })

        out := make([]any, 0, len(s))
        for i := range s {
                out = append(out, entries[i].o)
        }

        return out, nil
}

// visitPrimitive is a helper function that visits a primitive value in the JSON tree
func (o *Transformer) visitPrimitive(v any, _ string) (any, error) {
        return v, nil
}

// visitString is a helper function that visits a string value in the JSON tree
func (o *Transformer) visitString(v string, path string) (string, error) {
        for _, fn := range o.stringTransforms {
                var err error
                v, err = fn(path, v)
                if err != nil {
                        return "", err
                }
        }
        return v, nil
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package fuzz

import (
        "bytes"
        "encoding/json"
        "strings"

        "k8s.io/kops/pkg/jsonutils"
)

func FuzzWriteToken(data []byte) int {
        var buf bytes.Buffer
        out := jsonutils.NewJSONStreamWriter(&buf)
        in := json.NewDecoder(strings.NewReader(string(data)))
        token, err := in.Token()
        if err != nil {
                return -1
        }
        err = out.WriteToken(token)
        if err != nil {
                return 0
        }
        return 1
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package node

import (
        "fmt"

        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/node"
)

var deprecatedNodeLabels = map[string]string{
        `beta.kubernetes.io/arch`:                       `deprecated since v1.14; use "kubernetes.io/arch" instead`,
        `beta.kubernetes.io/os`:                         `deprecated since v1.14; use "kubernetes.io/os" instead`,
        `failure-domain.beta.kubernetes.io/region`:      `deprecated since v1.17; use "topology.kubernetes.io/region" instead`,
        `failure-domain.beta.kubernetes.io/zone`:        `deprecated since v1.17; use "topology.kubernetes.io/zone" instead`,
        `beta.kubernetes.io/instance-type`:              `deprecated since v1.17; use "node.kubernetes.io/instance-type" instead`,
        `app.kubernetes.io/created-by`:                  `deprecated since v1.9`,
        `scheduler.alpha.kubernetes.io/preferAvoidPods`: `deprecated since v1.22; use Taints and Tolerations instead`,
        `node-role.kubernetes.io/master`:                `use "node-role.kubernetes.io/control-plane" instead`,
}

// GetNodeLabelDeprecatedMessage returns the message for the deprecated node label
// and a bool indicating if the label is deprecated.
func GetNodeLabelDeprecatedMessage(key string) (string, bool) {
        msg, ok := deprecatedNodeLabels[key]
        return msg, ok
}

func GetWarningsForRuntimeClass(rc *node.RuntimeClass) []string {
        var warnings []string

        if rc != nil && rc.Scheduling != nil && rc.Scheduling.NodeSelector != nil {
                // use of deprecated node labels in scheduling's node affinity
                for key := range rc.Scheduling.NodeSelector {
                        if msg, deprecated := GetNodeLabelDeprecatedMessage(key); deprecated {
                                warnings = append(warnings, fmt.Sprintf("%s: %s", field.NewPath("scheduling", "nodeSelector"), msg))
                        }
                }
        }

        return warnings
}

// GetWarningsForNodeSelector tests if any of the node selector requirements in the template is deprecated.
// If there are deprecated node selector requirements in either match expressions or match labels, a warning is returned.
func GetWarningsForNodeSelector(nodeSelector *metav1.LabelSelector, fieldPath *field.Path) []string {
        if nodeSelector == nil {
                return nil
        }

        var warnings []string
        // use of deprecated node labels in matchLabelExpressions
        for i, expression := range nodeSelector.MatchExpressions {
                if msg, deprecated := GetNodeLabelDeprecatedMessage(expression.Key); deprecated {
                        warnings = append(
                                warnings,
                                fmt.Sprintf(
                                        "%s: %s is %s",
                                        fieldPath.Child("matchExpressions").Index(i).Child("key"),
                                        expression.Key,
                                        msg,
                                ),
                        )
                }
        }

        // use of deprecated node labels in matchLabels
        for label := range nodeSelector.MatchLabels {
                if msg, deprecated := GetNodeLabelDeprecatedMessage(label); deprecated {
                        warnings = append(warnings, fmt.Sprintf("%s: %s", fieldPath.Child("matchLabels").Child(label), msg))
                }
        }
        return warnings
}

// GetWarningsForNodeSelectorTerm checks match expressions of node selector term
func GetWarningsForNodeSelectorTerm(nodeSelectorTerm api.NodeSelectorTerm, checkLabelValue bool, fieldPath *field.Path) []string {
        var warnings []string
        // use of deprecated node labels in matchLabelExpressions
        for i, expression := range nodeSelectorTerm.MatchExpressions {
                if msg, deprecated := GetNodeLabelDeprecatedMessage(expression.Key); deprecated {
                        warnings = append(
                                warnings,
                                fmt.Sprintf(
                                        "%s: %s is %s",
                                        fieldPath.Child("matchExpressions").Index(i).Child("key"),
                                        expression.Key,
                                        msg,
                                ),
                        )
                }
                if checkLabelValue {
                        for index, value := range expression.Values {
                                for _, msg := range validation.IsValidLabelValue(value) {
                                        warnings = append(warnings,
                                                fmt.Sprintf(
                                                        "%s: %s is invalid, %s",
                                                        fieldPath.Child("matchExpressions").Index(i).Child("values").Index(index),
                                                        value,
                                                        msg,
                                                ))
                                }
                        }
                }
        }
        return warnings
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package persistentvolumeclaim

import (
        "fmt"

        "k8s.io/apimachinery/pkg/util/validation/field"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/core/helper"
        "k8s.io/kubernetes/pkg/features"
)

const (
        pvc                                  string = "PersistentVolumeClaim"
        volumeSnapshot                       string = "VolumeSnapshot"
        deprecatedStorageClassAnnotationsMsg        = `deprecated since v1.8; use "storageClassName" attribute instead`
)

// DropDisabledFields removes disabled fields from the pvc spec.
// This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a pvc spec.
func DropDisabledFields(pvcSpec, oldPVCSpec *core.PersistentVolumeClaimSpec) {
        // Drop the contents of the volumeAttributesClassName if the VolumeAttributesClass
        // feature gate is disabled.
        if !utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
                if oldPVCSpec == nil || oldPVCSpec.VolumeAttributesClassName == nil {
                        pvcSpec.VolumeAttributesClassName = nil
                }
        }

        // Drop the contents of the dataSourceRef field if the AnyVolumeDataSource
        // feature gate is disabled.
        if !utilfeature.DefaultFeatureGate.Enabled(features.AnyVolumeDataSource) {
                if !dataSourceRefInUse(oldPVCSpec) {
                        pvcSpec.DataSourceRef = nil
                }
        }

        // Drop the contents of the dataSourceRef field if the CrossNamespaceVolumeDataSource
        // feature gate is disabled and dataSourceRef.Namespace is specified.
        if !utilfeature.DefaultFeatureGate.Enabled(features.CrossNamespaceVolumeDataSource) &&
                pvcSpec.DataSourceRef != nil && pvcSpec.DataSourceRef.Namespace != nil && len(*pvcSpec.DataSourceRef.Namespace) != 0 {
                if !dataSourceRefInUse(oldPVCSpec) {
                        pvcSpec.DataSourceRef = nil
                }
        }
}

// EnforceDataSourceBackwardsCompatibility drops the data source field under certain conditions
// to maintain backwards compatibility with old behavior.
// See KEP 1495 for details.
// Specifically, if this is an update of a PVC with no data source, or a creation of a new PVC,
// and the dataSourceRef field is not filled in, then we will drop "invalid" data sources
// (anything other than a PVC or a VolumeSnapshot) from this request as if an empty PVC had
// been requested.
// This should be called after DropDisabledFields so that if the AnyVolumeDataSource feature
// gate is disabled, dataSourceRef will be forced to empty, ensuring pre-1.22 behavior.
// This should be called before NormalizeDataSources, so that data sources other than PVCs
// and VolumeSnapshots can only be set through the dataSourceRef field and not the dataSource
// field.
func EnforceDataSourceBackwardsCompatibility(pvcSpec, oldPVCSpec *core.PersistentVolumeClaimSpec) {
        // Check if the old PVC has a data source here is so that on updates from old clients
        // that omit dataSourceRef, we preserve the data source, even if it would have been
        // invalid to specify it at using the dataSource field at create.
        if dataSourceInUse(oldPVCSpec) {
                return
        }

        // Check if dataSourceRef is empty is because if it's not empty, then there is
        // definitely a newer client and it definitely either wants to create a non-empty
        // volume, or it wants to update a PVC that has a data source. Whether the
        // specified data source is valid or satisfiable is a matter for validation and
        // the volume populator code, but we can say with certainty that the client is
        // not expecting the legacy behavior of ignoring invalid data sources.
        if pvcSpec.DataSourceRef != nil {
                return
        }

        // Historically, we only allow PVCs and VolumeSnapshots in the dataSource field.
        // All other values are silently dropped.
        if !dataSourceIsPvcOrSnapshot(pvcSpec.DataSource) {
                pvcSpec.DataSource = nil
        }
}

func DropDisabledFieldsFromStatus(pvc, oldPVC *core.PersistentVolumeClaim) {
        if !utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
                if oldPVC == nil || oldPVC.Status.CurrentVolumeAttributesClassName == nil {
                        pvc.Status.CurrentVolumeAttributesClassName = nil
                }
                if oldPVC == nil || oldPVC.Status.ModifyVolumeStatus == nil {
                        pvc.Status.ModifyVolumeStatus = nil
                }
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure) {
                if !helper.ClaimContainsAllocatedResources(oldPVC) {
                        pvc.Status.AllocatedResources = nil
                }
                if !helper.ClaimContainsAllocatedResourceStatus(oldPVC) {
                        pvc.Status.AllocatedResourceStatuses = nil
                }
        }
}

func dataSourceInUse(oldPVCSpec *core.PersistentVolumeClaimSpec) bool {
        if oldPVCSpec == nil {
                return false
        }
        if oldPVCSpec.DataSource != nil || oldPVCSpec.DataSourceRef != nil {
                return true
        }
        return false
}

func dataSourceIsPvcOrSnapshot(dataSource *core.TypedLocalObjectReference) bool {
        if dataSource != nil {
                apiGroup := ""
                if dataSource.APIGroup != nil {
                        apiGroup = *dataSource.APIGroup
                }
                if dataSource.Kind == pvc &&
                        apiGroup == "" {
                        return true
                }

                if dataSource.Kind == volumeSnapshot && apiGroup == "snapshot.storage.k8s.io" {
                        return true
                }
        }
        return false
}

func dataSourceRefInUse(oldPVCSpec *core.PersistentVolumeClaimSpec) bool {
        if oldPVCSpec == nil {
                return false
        }
        if oldPVCSpec.DataSourceRef != nil {
                return true
        }
        return false
}

// NormalizeDataSources ensures that DataSource and DataSourceRef have the same contents
// as long as both are not explicitly set.
// This should be used by creates/gets of PVCs, but not updates
func NormalizeDataSources(pvcSpec *core.PersistentVolumeClaimSpec) {
        // Don't enable this behavior if the feature gate is not on
        if !utilfeature.DefaultFeatureGate.Enabled(features.AnyVolumeDataSource) {
                return
        }
        if pvcSpec.DataSource != nil && pvcSpec.DataSourceRef == nil {
                // Using the old way of setting a data source
                pvcSpec.DataSourceRef = &core.TypedObjectReference{
                        Kind: pvcSpec.DataSource.Kind,
                        Name: pvcSpec.DataSource.Name,
                }
                if pvcSpec.DataSource.APIGroup != nil {
                        apiGroup := *pvcSpec.DataSource.APIGroup
                        pvcSpec.DataSourceRef.APIGroup = &apiGroup
                }
        } else if pvcSpec.DataSourceRef != nil && pvcSpec.DataSource == nil {
                if pvcSpec.DataSourceRef.Namespace == nil || len(*pvcSpec.DataSourceRef.Namespace) == 0 {
                        // Using the new way of setting a data source
                        pvcSpec.DataSource = &core.TypedLocalObjectReference{
                                Kind: pvcSpec.DataSourceRef.Kind,
                                Name: pvcSpec.DataSourceRef.Name,
                        }
                        if pvcSpec.DataSourceRef.APIGroup != nil {
                                apiGroup := *pvcSpec.DataSourceRef.APIGroup
                                pvcSpec.DataSource.APIGroup = &apiGroup
                        }
                }
        }
}

func GetWarningsForPersistentVolumeClaim(pv *core.PersistentVolumeClaim) []string {
        var warnings []string

        if pv == nil {
                return nil
        }

        if _, ok := pv.ObjectMeta.Annotations[core.BetaStorageClassAnnotation]; ok {
                warnings = append(warnings,
                        fmt.Sprintf(
                                "%s: %s",
                                field.NewPath("metadata", "annotations").Key(core.BetaStorageClassAnnotation),
                                deprecatedStorageClassAnnotationsMsg,
                        ),
                )
        }

        warnings = append(warnings, GetWarningsForPersistentVolumeClaimSpec(field.NewPath("spec"), pv.Spec)...)

        return warnings
}

func GetWarningsForPersistentVolumeClaimSpec(fieldPath *field.Path, pvSpec core.PersistentVolumeClaimSpec) []string {

        var warnings []string
        requestValue := pvSpec.Resources.Requests[core.ResourceStorage]
        if requestValue.MilliValue()%int64(1000) != int64(0) {
                warnings = append(warnings, fmt.Sprintf(
                        "%s: fractional byte value %q is invalid, must be an integer",
                        fieldPath.Child("resources").Child("requests").Key(core.ResourceStorage.String()), requestValue.String()))
        }
        limitValue := pvSpec.Resources.Limits[core.ResourceStorage]
        if limitValue.MilliValue()%int64(1000) != int64(0) {
                warnings = append(warnings, fmt.Sprintf(
                        "%s: fractional byte value %q is invalid, must be an integer",
                        fieldPath.Child("resources").Child("limits").Key(core.ResourceStorage.String()), limitValue.String()))
        }
        return warnings
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package pod

import (
        "fmt"
        "iter"
        "strings"

        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        metavalidation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
        "k8s.io/apimachinery/pkg/util/sets"
        "k8s.io/apimachinery/pkg/util/validation"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/core/helper"
        apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
        "k8s.io/kubernetes/pkg/features"
)

// ContainerType signifies container type
type ContainerType int

const (
        // Containers is for normal containers
        Containers ContainerType = 1 << iota
        // InitContainers is for init containers
        InitContainers
        // EphemeralContainers is for ephemeral containers
        EphemeralContainers
)

// AllContainers specifies that all containers be visited
const AllContainers ContainerType = (InitContainers | Containers | EphemeralContainers)

// AllFeatureEnabledContainers returns a ContainerType mask which includes all container
// types except for the ones guarded by feature gate.
func AllFeatureEnabledContainers() ContainerType {
        return AllContainers
}

// ContainerVisitor is called with each container spec, and returns true
// if visiting should continue.
type ContainerVisitor func(container *api.Container, containerType ContainerType) (shouldContinue bool)

// VisitContainers invokes the visitor function with a pointer to every container
// spec in the given pod spec with type set in mask. If visitor returns false,
// visiting is short-circuited. VisitContainers returns true if visiting completes,
// false if visiting was short-circuited.
func VisitContainers(podSpec *api.PodSpec, mask ContainerType, visitor ContainerVisitor) bool {
        for c, t := range ContainerIter(podSpec, mask) {
                if !visitor(c, t) {
                        return false
                }
        }
        return true
}

// ContainerIter returns an iterator over all containers in the given pod spec with a masked type.
// The iteration order is InitContainers, then main Containers, then EphemeralContainers.
func ContainerIter(podSpec *api.PodSpec, mask ContainerType) iter.Seq2[*api.Container, ContainerType] {
        return func(yield func(*api.Container, ContainerType) bool) {
                if mask&InitContainers != 0 {
                        for i := range podSpec.InitContainers {
                                if !yield(&podSpec.InitContainers[i], InitContainers) {
                                        return
                                }
                        }
                }
                if mask&Containers != 0 {
                        for i := range podSpec.Containers {
                                if !yield(&podSpec.Containers[i], Containers) {
                                        return
                                }
                        }
                }
                if mask&EphemeralContainers != 0 {
                        for i := range podSpec.EphemeralContainers {
                                if !yield((*api.Container)(&podSpec.EphemeralContainers[i].EphemeralContainerCommon), EphemeralContainers) {
                                        return
                                }
                        }
                }
        }
}

// Visitor is called with each object name, and returns true if visiting should continue
type Visitor func(name string) (shouldContinue bool)

func skipEmptyNames(visitor Visitor) Visitor {
        return func(name string) bool {
                if len(name) == 0 {
                        // continue visiting
                        return true
                }
                // delegate to visitor
                return visitor(name)
        }
}

// VisitPodSecretNames invokes the visitor function with the name of every secret
// referenced by the pod spec. If visitor returns false, visiting is short-circuited.
// Transitive references (e.g. pod -> pvc -> pv -> secret) are not visited.
// Returns true if visiting completed, false if visiting was short-circuited.
func VisitPodSecretNames(pod *api.Pod, visitor Visitor, containerType ContainerType) bool {
        visitor = skipEmptyNames(visitor)
        for _, reference := range pod.Spec.ImagePullSecrets {
                if !visitor(reference.Name) {
                        return false
                }
        }
        VisitContainers(&pod.Spec, containerType, func(c *api.Container, containerType ContainerType) bool {
                return visitContainerSecretNames(c, visitor)
        })
        var source *api.VolumeSource
        for i := range pod.Spec.Volumes {
                source = &pod.Spec.Volumes[i].VolumeSource
                switch {
                case source.AzureFile != nil:
                        if len(source.AzureFile.SecretName) > 0 && !visitor(source.AzureFile.SecretName) {
                                return false
                        }
                case source.CephFS != nil:
                        if source.CephFS.SecretRef != nil && !visitor(source.CephFS.SecretRef.Name) {
                                return false
                        }
                case source.Cinder != nil:
                        if source.Cinder.SecretRef != nil && !visitor(source.Cinder.SecretRef.Name) {
                                return false
                        }
                case source.FlexVolume != nil:
                        if source.FlexVolume.SecretRef != nil && !visitor(source.FlexVolume.SecretRef.Name) {
                                return false
                        }
                case source.Projected != nil:
                        for j := range source.Projected.Sources {
                                if source.Projected.Sources[j].Secret != nil {
                                        if !visitor(source.Projected.Sources[j].Secret.Name) {
                                                return false
                                        }
                                }
                        }
                case source.RBD != nil:
                        if source.RBD.SecretRef != nil && !visitor(source.RBD.SecretRef.Name) {
                                return false
                        }
                case source.Secret != nil:
                        if !visitor(source.Secret.SecretName) {
                                return false
                        }
                case source.ScaleIO != nil:
                        if source.ScaleIO.SecretRef != nil && !visitor(source.ScaleIO.SecretRef.Name) {
                                return false
                        }
                case source.ISCSI != nil:
                        if source.ISCSI.SecretRef != nil && !visitor(source.ISCSI.SecretRef.Name) {
                                return false
                        }
                case source.StorageOS != nil:
                        if source.StorageOS.SecretRef != nil && !visitor(source.StorageOS.SecretRef.Name) {
                                return false
                        }
                case source.CSI != nil:
                        if source.CSI.NodePublishSecretRef != nil && !visitor(source.CSI.NodePublishSecretRef.Name) {
                                return false
                        }
                }
        }
        return true
}

func visitContainerSecretNames(container *api.Container, visitor Visitor) bool {
        for _, env := range container.EnvFrom {
                if env.SecretRef != nil {
                        if !visitor(env.SecretRef.Name) {
                                return false
                        }
                }
        }
        for _, envVar := range container.Env {
                if envVar.ValueFrom != nil && envVar.ValueFrom.SecretKeyRef != nil {
                        if !visitor(envVar.ValueFrom.SecretKeyRef.Name) {
                                return false
                        }
                }
        }
        return true
}

// VisitPodConfigmapNames invokes the visitor function with the name of every configmap
// referenced by the pod spec. If visitor returns false, visiting is short-circuited.
// Transitive references (e.g. pod -> pvc -> pv -> secret) are not visited.
// Returns true if visiting completed, false if visiting was short-circuited.
func VisitPodConfigmapNames(pod *api.Pod, visitor Visitor, containerType ContainerType) bool {
        visitor = skipEmptyNames(visitor)
        VisitContainers(&pod.Spec, containerType, func(c *api.Container, containerType ContainerType) bool {
                return visitContainerConfigmapNames(c, visitor)
        })
        var source *api.VolumeSource
        for i := range pod.Spec.Volumes {
                source = &pod.Spec.Volumes[i].VolumeSource
                switch {
                case source.Projected != nil:
                        for j := range source.Projected.Sources {
                                if source.Projected.Sources[j].ConfigMap != nil {
                                        if !visitor(source.Projected.Sources[j].ConfigMap.Name) {
                                                return false
                                        }
                                }
                        }
                case source.ConfigMap != nil:
                        if !visitor(source.ConfigMap.Name) {
                                return false
                        }
                }
        }
        return true
}

func visitContainerConfigmapNames(container *api.Container, visitor Visitor) bool {
        for _, env := range container.EnvFrom {
                if env.ConfigMapRef != nil {
                        if !visitor(env.ConfigMapRef.Name) {
                                return false
                        }
                }
        }
        for _, envVar := range container.Env {
                if envVar.ValueFrom != nil && envVar.ValueFrom.ConfigMapKeyRef != nil {
                        if !visitor(envVar.ValueFrom.ConfigMapKeyRef.Name) {
                                return false
                        }
                }
        }
        return true
}

// IsPodReady returns true if a pod is ready; false otherwise.
func IsPodReady(pod *api.Pod) bool {
        return IsPodReadyConditionTrue(pod.Status)
}

// IsPodReadyConditionTrue returns true if a pod is ready; false otherwise.
func IsPodReadyConditionTrue(status api.PodStatus) bool {
        condition := GetPodReadyCondition(status)
        return condition != nil && condition.Status == api.ConditionTrue
}

// GetPodReadyCondition extracts the pod ready condition from the given status and returns that.
// Returns nil if the condition is not present.
func GetPodReadyCondition(status api.PodStatus) *api.PodCondition {
        _, condition := GetPodCondition(&status, api.PodReady)
        return condition
}

// GetPodCondition extracts the provided condition from the given status and returns that.
// Returns nil and -1 if the condition is not present, and the index of the located condition.
func GetPodCondition(status *api.PodStatus, conditionType api.PodConditionType) (int, *api.PodCondition) {
        if status == nil {
                return -1, nil
        }
        for i := range status.Conditions {
                if status.Conditions[i].Type == conditionType {
                        return i, &status.Conditions[i]
                }
        }
        return -1, nil
}

// UpdatePodCondition updates existing pod condition or creates a new one. Sets LastTransitionTime to now if the
// status has changed.
// Returns true if pod condition has changed or has been added.
func UpdatePodCondition(status *api.PodStatus, condition *api.PodCondition) bool {
        condition.LastTransitionTime = metav1.Now()
        // Try to find this pod condition.
        conditionIndex, oldCondition := GetPodCondition(status, condition.Type)

        if oldCondition == nil {
                // We are adding new pod condition.
                status.Conditions = append(status.Conditions, *condition)
                return true
        }
        // We are updating an existing condition, so we need to check if it has changed.
        if condition.Status == oldCondition.Status {
                condition.LastTransitionTime = oldCondition.LastTransitionTime
        }

        isEqual := condition.Status == oldCondition.Status &&
                condition.Reason == oldCondition.Reason &&
                condition.Message == oldCondition.Message &&
                condition.LastProbeTime.Equal(&oldCondition.LastProbeTime) &&
                condition.LastTransitionTime.Equal(&oldCondition.LastTransitionTime)

        status.Conditions[conditionIndex] = *condition
        // Return true if one of the fields have changed.
        return !isEqual
}

func checkContainerUseIndivisibleHugePagesValues(container api.Container) bool {
        for resourceName, quantity := range container.Resources.Limits {
                if helper.IsHugePageResourceName(resourceName) {
                        if !helper.IsHugePageResourceValueDivisible(resourceName, quantity) {
                                return true
                        }
                }
        }

        for resourceName, quantity := range container.Resources.Requests {
                if helper.IsHugePageResourceName(resourceName) {
                        if !helper.IsHugePageResourceValueDivisible(resourceName, quantity) {
                                return true
                        }
                }
        }

        return false
}

// usesIndivisibleHugePagesValues returns true if the one of the containers uses non-integer multiple
// of huge page unit size
func usesIndivisibleHugePagesValues(podSpec *api.PodSpec) bool {
        foundIndivisibleHugePagesValue := false
        VisitContainers(podSpec, AllContainers, func(c *api.Container, containerType ContainerType) bool {
                if checkContainerUseIndivisibleHugePagesValues(*c) {
                        foundIndivisibleHugePagesValue = true
                }
                return !foundIndivisibleHugePagesValue // continue visiting if we haven't seen an invalid value yet
        })

        if foundIndivisibleHugePagesValue {
                return true
        }

        for resourceName, quantity := range podSpec.Overhead {
                if helper.IsHugePageResourceName(resourceName) {
                        if !helper.IsHugePageResourceValueDivisible(resourceName, quantity) {
                                return true
                        }
                }
        }

        return false
}

// hasInvalidTopologySpreadConstraintLabelSelector return true if spec.TopologySpreadConstraints have any entry with invalid labelSelector
func hasInvalidTopologySpreadConstraintLabelSelector(spec *api.PodSpec) bool {
        for _, constraint := range spec.TopologySpreadConstraints {
                errs := metavalidation.ValidateLabelSelector(constraint.LabelSelector, metavalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: false}, nil)
                if len(errs) != 0 {
                        return true
                }
        }
        return false
}

// hasInvalidTopologySpreadConstrainMatchLabelKeys return true if spec.TopologySpreadConstraints have any entry with invalid MatchLabelKeys
func hasInvalidTopologySpreadConstrainMatchLabelKeys(spec *api.PodSpec) bool {
        for _, constraint := range spec.TopologySpreadConstraints {
                errs := apivalidation.ValidateMatchLabelKeysAndMismatchLabelKeys(nil, constraint.MatchLabelKeys, nil, constraint.LabelSelector)
                if len(errs) != 0 {
                        return true
                }
        }
        return false
}

// hasLegacyInvalidTopologySpreadConstrainMatchLabelKeys return true if spec.TopologySpreadConstraints have any entry with invalid MatchLabelKeys against legacy validation
func hasLegacyInvalidTopologySpreadConstrainMatchLabelKeys(spec *api.PodSpec) bool {
        for _, constraint := range spec.TopologySpreadConstraints {
                errs := apivalidation.ValidateMatchLabelKeysInTopologySpread(nil, constraint.MatchLabelKeys, constraint.LabelSelector)
                if len(errs) != 0 {
                        return true
                }
        }
        return false
}

// hasNonLocalProjectedTokenPath return true if spec.Volumes have any entry with non-local projected token path
func hasNonLocalProjectedTokenPath(spec *api.PodSpec) bool {
        for _, volume := range spec.Volumes {
                if volume.Projected != nil {
                        for _, source := range volume.Projected.Sources {
                                if source.ServiceAccountToken == nil {
                                        continue
                                }
                                errs := apivalidation.ValidateLocalNonReservedPath(source.ServiceAccountToken.Path, nil)
                                if len(errs) != 0 {
                                        return true
                                }
                        }
                }
        }
        return false
}

// GetValidationOptionsFromPodSpecAndMeta returns validation options based on pod specs and metadata
func GetValidationOptionsFromPodSpecAndMeta(podSpec, oldPodSpec *api.PodSpec, podMeta, oldPodMeta *metav1.ObjectMeta) apivalidation.PodValidationOptions {
        // default pod validation options based on feature gate
        opts := apivalidation.PodValidationOptions{
                AllowInvalidPodDeletionCost: !utilfeature.DefaultFeatureGate.Enabled(features.PodDeletionCost),
                // Do not allow pod spec to use non-integer multiple of huge page unit size default
                AllowIndivisibleHugePagesValues:                     false,
                AllowInvalidLabelValueInSelector:                    false,
                AllowInvalidTopologySpreadConstraintLabelSelector:   false,
                AllowNamespacedSysctlsForHostNetAndHostIPC:          false,
                AllowNonLocalProjectedTokenPath:                     false,
                AllowPodLifecycleSleepActionZeroValue:               utilfeature.DefaultFeatureGate.Enabled(features.PodLifecycleSleepActionAllowZero),
                PodLevelResourcesEnabled:                            utilfeature.DefaultFeatureGate.Enabled(features.PodLevelResources),
                AllowInvalidLabelValueInRequiredNodeAffinity:        false,
                AllowSidecarResizePolicy:                            utilfeature.DefaultFeatureGate.Enabled(features.InPlacePodVerticalScaling),
                AllowMatchLabelKeysInPodTopologySpread:              utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodTopologySpread),
                AllowMatchLabelKeysInPodTopologySpreadSelectorMerge: utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodTopologySpreadSelectorMerge),
                OldPodViolatesMatchLabelKeysValidation:              false,
                OldPodViolatesLegacyMatchLabelKeysValidation:        false,
                AllowContainerRestartPolicyRules:                    utilfeature.DefaultFeatureGate.Enabled(features.ContainerRestartRules),
                AllowUserNamespacesWithVolumeDevices:                false,
        }

        // If old spec uses relaxed validation or enabled the RelaxedEnvironmentVariableValidation feature gate,
        // we must allow it
        opts.AllowRelaxedEnvironmentVariableValidation = useRelaxedEnvironmentVariableValidation(podSpec, oldPodSpec)
        opts.AllowRelaxedDNSSearchValidation = useRelaxedDNSSearchValidation(oldPodSpec)
        opts.AllowEnvFilesValidation = useAllowEnvFilesValidation(oldPodSpec)

        opts.AllowOnlyRecursiveSELinuxChangePolicy = useOnlyRecursiveSELinuxChangePolicy(oldPodSpec)

        if oldPodSpec != nil {
                // if old spec used non-integer multiple of huge page unit size, we must allow it
                opts.AllowIndivisibleHugePagesValues = usesIndivisibleHugePagesValues(oldPodSpec)

                opts.AllowInvalidLabelValueInSelector = hasInvalidLabelValueInAffinitySelector(oldPodSpec)
                opts.AllowInvalidLabelValueInRequiredNodeAffinity = hasInvalidLabelValueInRequiredNodeAffinity(oldPodSpec)
                // if old spec has invalid labelSelector in topologySpreadConstraint, we must allow it
                opts.AllowInvalidTopologySpreadConstraintLabelSelector = hasInvalidTopologySpreadConstraintLabelSelector(oldPodSpec)
                if opts.AllowMatchLabelKeysInPodTopologySpread {
                        if opts.AllowMatchLabelKeysInPodTopologySpreadSelectorMerge {
                                // If old spec has invalid MatchLabelKeys, we must set true
                                opts.OldPodViolatesMatchLabelKeysValidation = hasInvalidTopologySpreadConstrainMatchLabelKeys(oldPodSpec)
                        } else {
                                // If old spec has invalid MatchLabelKeys against legacy validation, we must set true
                                opts.OldPodViolatesLegacyMatchLabelKeysValidation = hasLegacyInvalidTopologySpreadConstrainMatchLabelKeys(oldPodSpec)
                        }
                }
                // if old spec has an invalid projected token volume path, we must allow it
                opts.AllowNonLocalProjectedTokenPath = hasNonLocalProjectedTokenPath(oldPodSpec)

                // if old spec has invalid sysctl with hostNet or hostIPC, we must allow it when update
                if oldPodSpec.SecurityContext != nil && len(oldPodSpec.SecurityContext.Sysctls) != 0 {
                        for _, s := range oldPodSpec.SecurityContext.Sysctls {
                                err := apivalidation.ValidateHostSysctl(s.Name, oldPodSpec.SecurityContext, nil)
                                if err != nil {
                                        opts.AllowNamespacedSysctlsForHostNetAndHostIPC = true
                                        break
                                }
                        }
                }

                opts.AllowPodLifecycleSleepActionZeroValue = opts.AllowPodLifecycleSleepActionZeroValue || podLifecycleSleepActionZeroValueInUse(oldPodSpec)
                // If oldPod has resize policy set on the restartable init container, we must allow it
                opts.AllowSidecarResizePolicy = opts.AllowSidecarResizePolicy || hasRestartableInitContainerResizePolicy(oldPodSpec)

                opts.AllowContainerRestartPolicyRules = opts.AllowContainerRestartPolicyRules || containerRestartRulesInUse(oldPodSpec)

                // If old spec has userns and volume devices (doesn't work), we still allow
                // modifications to it.
                opts.AllowUserNamespacesWithVolumeDevices = hasUserNamespacesWithVolumeDevices(oldPodSpec)
        }
        if oldPodMeta != nil && !opts.AllowInvalidPodDeletionCost {
                // This is an update, so validate only if the existing object was valid.
                _, err := helper.GetDeletionCostFromPodAnnotations(oldPodMeta.Annotations)
                opts.AllowInvalidPodDeletionCost = err != nil
        }

        return opts
}

func useRelaxedEnvironmentVariableValidation(podSpec, oldPodSpec *api.PodSpec) bool {
        if utilfeature.DefaultFeatureGate.Enabled(features.RelaxedEnvironmentVariableValidation) {
                return true
        }

        var oldPodEnvVarNames, podEnvVarNames sets.Set[string]
        if oldPodSpec != nil {
                oldPodEnvVarNames = gatherPodEnvVarNames(oldPodSpec)
        }

        if podSpec != nil {
                podEnvVarNames = gatherPodEnvVarNames(podSpec)
        }

        for env := range podEnvVarNames {
                if relaxedEnvVarUsed(env, oldPodEnvVarNames) {
                        return true
                }
        }

        return false
}

func useRelaxedDNSSearchValidation(oldPodSpec *api.PodSpec) bool {
        // Return true early if feature gate is enabled
        if utilfeature.DefaultFeatureGate.Enabled(features.RelaxedDNSSearchValidation) {
                return true
        }

        // Return false early if there is no DNSConfig or Searches.
        if oldPodSpec == nil || oldPodSpec.DNSConfig == nil || oldPodSpec.DNSConfig.Searches == nil {
                return false
        }

        return hasDotOrUnderscore(oldPodSpec.DNSConfig.Searches)
}

// Helper function to check if any domain is a dot or contains an underscore.
func hasDotOrUnderscore(searches []string) bool {
        for _, domain := range searches {
                if domain == "." || strings.Contains(domain, "_") {
                        return true
                }
        }
        return false
}

func useAllowEnvFilesValidation(oldPodSpec *api.PodSpec) bool {
        // Return true early if feature gate is enabled
        if utilfeature.DefaultFeatureGate.Enabled(features.EnvFiles) {
                return true
        }

        if oldPodSpec == nil {
                return false
        }

        for _, container := range oldPodSpec.Containers {
                if hasEnvFileKeyRef(container.Env) {
                        return true
                }
        }
        for _, container := range oldPodSpec.InitContainers {
                if hasEnvFileKeyRef(container.Env) {
                        return true
                }
        }
        for _, container := range oldPodSpec.EphemeralContainers {
                if hasEnvFileKeyRef(container.Env) {
                        return true
                }
        }

        return false
}

func hasEnvFileKeyRef(envs []api.EnvVar) bool {
        for _, env := range envs {
                if env.ValueFrom != nil && env.ValueFrom.FileKeyRef != nil {
                        return true
                }
        }
        return false
}

func gatherPodEnvVarNames(podSpec *api.PodSpec) sets.Set[string] {
        podEnvVarNames := sets.Set[string]{}

        for _, c := range podSpec.Containers {
                for _, env := range c.Env {
                        podEnvVarNames.Insert(env.Name)
                }

                for _, env := range c.EnvFrom {
                        podEnvVarNames.Insert(env.Prefix)
                }
        }

        for _, c := range podSpec.InitContainers {
                for _, env := range c.Env {
                        podEnvVarNames.Insert(env.Name)
                }

                for _, env := range c.EnvFrom {
                        podEnvVarNames.Insert(env.Prefix)
                }
        }

        for _, c := range podSpec.EphemeralContainers {
                for _, env := range c.Env {
                        podEnvVarNames.Insert(env.Name)
                }

                for _, env := range c.EnvFrom {
                        podEnvVarNames.Insert(env.Prefix)
                }
        }

        return podEnvVarNames
}

func relaxedEnvVarUsed(name string, oldPodEnvVarNames sets.Set[string]) bool {
        // A length of 0 means this is not an update request,
        // or the old pod does not exist in the env.
        // We will let the feature gate decide whether to use relaxed rules.
        if oldPodEnvVarNames.Len() == 0 {
                return false
        }

        if len(validation.IsEnvVarName(name)) == 0 || len(validation.IsRelaxedEnvVarName(name)) != 0 {
                // It's either a valid name by strict rules or an invalid name under relaxed rules.
                // Either way, we'll use strict rules to validate.
                return false
        }

        // The name in question failed strict rules but passed relaxed rules.
        if oldPodEnvVarNames.Has(name) {
                // This relaxed-rules name was already in use.
                return true
        }

        return false
}

// GetValidationOptionsFromPodTemplate will return pod validation options for specified template.
func GetValidationOptionsFromPodTemplate(podTemplate, oldPodTemplate *api.PodTemplateSpec) apivalidation.PodValidationOptions {
        var newPodSpec, oldPodSpec *api.PodSpec
        var newPodMeta, oldPodMeta *metav1.ObjectMeta
        // we have to be careful about nil pointers here
        // replication controller in particular is prone to passing nil
        if podTemplate != nil {
                newPodSpec = &podTemplate.Spec
                newPodMeta = &podTemplate.ObjectMeta
        }
        if oldPodTemplate != nil {
                oldPodSpec = &oldPodTemplate.Spec
                oldPodMeta = &oldPodTemplate.ObjectMeta
        }
        return GetValidationOptionsFromPodSpecAndMeta(newPodSpec, oldPodSpec, newPodMeta, oldPodMeta)
}

// DropDisabledTemplateFields removes disabled fields from the pod template metadata and spec.
// This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a PodTemplateSpec
func DropDisabledTemplateFields(podTemplate, oldPodTemplate *api.PodTemplateSpec) {
        var (
                podSpec           *api.PodSpec
                podAnnotations    map[string]string
                oldPodSpec        *api.PodSpec
                oldPodAnnotations map[string]string
        )
        if podTemplate != nil {
                podSpec = &podTemplate.Spec
                podAnnotations = podTemplate.Annotations
        }
        if oldPodTemplate != nil {
                oldPodSpec = &oldPodTemplate.Spec
                oldPodAnnotations = oldPodTemplate.Annotations
        }
        dropDisabledFields(podSpec, podAnnotations, oldPodSpec, oldPodAnnotations)
}

// DropDisabledPodFields removes disabled fields from the pod metadata and spec.
// This should be called from PrepareForCreate/PrepareForUpdate for all resources containing a Pod
func DropDisabledPodFields(pod, oldPod *api.Pod) {
        var (
                podSpec           *api.PodSpec
                podStatus         *api.PodStatus
                podAnnotations    map[string]string
                oldPodSpec        *api.PodSpec
                oldPodStatus      *api.PodStatus
                oldPodAnnotations map[string]string
        )
        if pod != nil {
                podSpec = &pod.Spec
                podStatus = &pod.Status
                podAnnotations = pod.Annotations
        }
        if oldPod != nil {
                oldPodSpec = &oldPod.Spec
                oldPodStatus = &oldPod.Status
                oldPodAnnotations = oldPod.Annotations
        }
        dropDisabledFields(podSpec, podAnnotations, oldPodSpec, oldPodAnnotations)
        dropDisabledPodStatusFields(podStatus, oldPodStatus, podSpec, oldPodSpec)
}

// dropDisabledFields removes disabled fields from the pod metadata and spec.
func dropDisabledFields(
        podSpec *api.PodSpec, podAnnotations map[string]string,
        oldPodSpec *api.PodSpec, oldPodAnnotations map[string]string,
) {
        // the new spec must always be non-nil
        if podSpec == nil {
                podSpec = &api.PodSpec{}
        }

        // If the feature is disabled and not in use, drop the hostUsers field.
        if !utilfeature.DefaultFeatureGate.Enabled(features.UserNamespacesSupport) && !hostUsersInUse(oldPodSpec) {
                // Drop the field in podSpec only if SecurityContext is not nil.
                // If it is nil, there is no need to set hostUsers=nil (it will be nil too).
                if podSpec.SecurityContext != nil {
                        podSpec.SecurityContext.HostUsers = nil
                }
        }

        // If the feature is disabled and not in use, drop the SupplementalGroupsPolicy field.
        if !utilfeature.DefaultFeatureGate.Enabled(features.SupplementalGroupsPolicy) && !supplementalGroupsPolicyInUse(oldPodSpec) {
                // Drop the field in podSpec only if SecurityContext is not nil.
                // If it is nil, there is no need to set supplementalGroupsPolicy=nil (it will be nil too).
                if podSpec.SecurityContext != nil {
                        podSpec.SecurityContext.SupplementalGroupsPolicy = nil
                }
        }

        dropDisabledPodLevelResources(podSpec, oldPodSpec)
        dropDisabledProcMountField(podSpec, oldPodSpec)

        dropDisabledNodeInclusionPolicyFields(podSpec, oldPodSpec)
        dropDisabledMatchLabelKeysFieldInTopologySpread(podSpec, oldPodSpec)
        dropDisabledMatchLabelKeysFieldInPodAffinity(podSpec, oldPodSpec)
        dropDisabledDynamicResourceAllocationFields(podSpec, oldPodSpec)
        dropDisabledClusterTrustBundleProjection(podSpec, oldPodSpec)
        dropDisabledPodCertificateProjection(podSpec, oldPodSpec)

        if !utilfeature.DefaultFeatureGate.Enabled(features.InPlacePodVerticalScaling) && !inPlacePodVerticalScalingInUse(oldPodSpec) {
                // Drop ResizePolicy fields. Don't drop updates to Resources field as template.spec.resources
                // field is mutable for certain controllers. Let ValidatePodUpdate handle it.
                for i := range podSpec.Containers {
                        podSpec.Containers[i].ResizePolicy = nil
                }
                for i := range podSpec.InitContainers {
                        podSpec.InitContainers[i].ResizePolicy = nil
                }
                for i := range podSpec.EphemeralContainers {
                        podSpec.EphemeralContainers[i].ResizePolicy = nil
                }
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.SidecarContainers) && !restartableInitContainersInUse(oldPodSpec) {
                // Drop the RestartPolicy field of init containers.
                for i := range podSpec.InitContainers {
                        podSpec.InitContainers[i].RestartPolicy = nil
                }
                // For other types of containers, validateContainers will handle them.
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.ContainerRestartRules) && !containerRestartRulesInUse(oldPodSpec) {
                dropContainerRestartRules(podSpec)
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.RecursiveReadOnlyMounts) && !rroInUse(oldPodSpec) {
                for i := range podSpec.Containers {
                        for j := range podSpec.Containers[i].VolumeMounts {
                                podSpec.Containers[i].VolumeMounts[j].RecursiveReadOnly = nil
                        }
                }
                for i := range podSpec.InitContainers {
                        for j := range podSpec.InitContainers[i].VolumeMounts {
                                podSpec.InitContainers[i].VolumeMounts[j].RecursiveReadOnly = nil
                        }
                }
                for i := range podSpec.EphemeralContainers {
                        for j := range podSpec.EphemeralContainers[i].VolumeMounts {
                                podSpec.EphemeralContainers[i].VolumeMounts[j].RecursiveReadOnly = nil
                        }
                }
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.HostnameOverride) && !setHostnameOverrideInUse(oldPodSpec) {
                // Set HostnameOverride to nil only if feature is disabled and it is not used
                podSpec.HostnameOverride = nil
        }

        dropFileKeyRefInUse(podSpec, oldPodSpec)
        dropPodLifecycleSleepAction(podSpec, oldPodSpec)
        dropImageVolumes(podSpec, oldPodSpec)
        dropSELinuxChangePolicy(podSpec, oldPodSpec)
        dropContainerStopSignals(podSpec, oldPodSpec)
}

// setHostnameOverrideInUse returns true if any pod's spec defines HostnameOverride field.
func setHostnameOverrideInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil || podSpec.HostnameOverride == nil {
                return false
        }
        return true
}

func dropFileKeyRefInUse(podSpec, oldPodSpec *api.PodSpec) {
        if utilfeature.DefaultFeatureGate.Enabled(features.EnvFiles) || podFileKeyRefInUse(oldPodSpec) {
                return
        }

        VisitContainers(podSpec, AllContainers, func(c *api.Container, _ ContainerType) bool {
                for i := range c.Env {
                        if c.Env[i].ValueFrom != nil && c.Env[i].ValueFrom.FileKeyRef != nil {
                                c.Env[i].ValueFrom.FileKeyRef = nil
                        }
                }
                return true
        })
}

func podFileKeyRefInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }

        var inUse bool
        VisitContainers(podSpec, AllContainers, func(c *api.Container, _ ContainerType) bool {
                for _, env := range c.Env {
                        if env.ValueFrom != nil && env.ValueFrom.FileKeyRef != nil {
                                inUse = true
                                return false
                        }
                }
                return true
        })
        return inUse
}

func dropContainerStopSignals(podSpec, oldPodSpec *api.PodSpec) {
        if utilfeature.DefaultFeatureGate.Enabled(features.ContainerStopSignals) || containerStopSignalsInUse(oldPodSpec) {
                return
        }

        wipeLifecycle := func(ctr *api.Container) {
                if ctr.Lifecycle == nil {
                        return
                }
                if ctr.Lifecycle.StopSignal != nil {
                        ctr.Lifecycle.StopSignal = nil
                        if *ctr.Lifecycle == (api.Lifecycle{}) {
                                ctr.Lifecycle = nil
                        }
                }
        }

        VisitContainers(podSpec, AllContainers, func(c *api.Container, containerType ContainerType) bool {
                if c.Lifecycle == nil {
                        return true
                }
                wipeLifecycle(c)
                return true
        })
}

func containerStopSignalsInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        var inUse bool
        VisitContainers(podSpec, AllContainers, func(c *api.Container, containerType ContainerType) bool {
                if c.Lifecycle == nil {
                        return true
                }
                if c.Lifecycle.StopSignal != nil {
                        inUse = true
                        return false
                }
                return true
        })
        return inUse
}

func dropDisabledPodLevelResources(podSpec, oldPodSpec *api.PodSpec) {
        // If the feature is disabled and not in use, drop Resources at the pod-level
        // from PodSpec.
        if !utilfeature.DefaultFeatureGate.Enabled(features.PodLevelResources) && !podLevelResourcesInUse(oldPodSpec) {
                podSpec.Resources = nil
        }
}

func dropPodLifecycleSleepAction(podSpec, oldPodSpec *api.PodSpec) {
        if utilfeature.DefaultFeatureGate.Enabled(features.PodLifecycleSleepAction) || podLifecycleSleepActionInUse(oldPodSpec) {
                return
        }

        adjustLifecycle := func(lifecycle *api.Lifecycle) {
                if lifecycle.PreStop != nil && lifecycle.PreStop.Sleep != nil {
                        lifecycle.PreStop.Sleep = nil
                        if lifecycle.PreStop.Exec == nil && lifecycle.PreStop.HTTPGet == nil && lifecycle.PreStop.TCPSocket == nil {
                                lifecycle.PreStop = nil
                        }
                }
                if lifecycle.PostStart != nil && lifecycle.PostStart.Sleep != nil {
                        lifecycle.PostStart.Sleep = nil
                        if lifecycle.PostStart.Exec == nil && lifecycle.PostStart.HTTPGet == nil && lifecycle.PostStart.TCPSocket == nil {
                                lifecycle.PostStart = nil
                        }
                }
        }

        for i := range podSpec.Containers {
                if podSpec.Containers[i].Lifecycle == nil {
                        continue
                }
                adjustLifecycle(podSpec.Containers[i].Lifecycle)
                if podSpec.Containers[i].Lifecycle.PreStop == nil && podSpec.Containers[i].Lifecycle.PostStart == nil && podSpec.Containers[i].Lifecycle.StopSignal == nil {
                        podSpec.Containers[i].Lifecycle = nil
                }
        }

        for i := range podSpec.InitContainers {
                if podSpec.InitContainers[i].Lifecycle == nil {
                        continue
                }
                adjustLifecycle(podSpec.InitContainers[i].Lifecycle)
                if podSpec.InitContainers[i].Lifecycle.PreStop == nil && podSpec.InitContainers[i].Lifecycle.PostStart == nil && podSpec.InitContainers[i].Lifecycle.StopSignal == nil {
                        podSpec.InitContainers[i].Lifecycle = nil
                }
        }

        for i := range podSpec.EphemeralContainers {
                if podSpec.EphemeralContainers[i].Lifecycle == nil {
                        continue
                }
                adjustLifecycle(podSpec.EphemeralContainers[i].Lifecycle)
                if podSpec.EphemeralContainers[i].Lifecycle.PreStop == nil && podSpec.EphemeralContainers[i].Lifecycle.PostStart == nil && podSpec.EphemeralContainers[i].Lifecycle.StopSignal == nil {
                        podSpec.EphemeralContainers[i].Lifecycle = nil
                }
        }
}

func podLifecycleSleepActionInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        var inUse bool
        VisitContainers(podSpec, AllContainers, func(c *api.Container, containerType ContainerType) bool {
                if c.Lifecycle == nil {
                        return true
                }
                if c.Lifecycle.PreStop != nil && c.Lifecycle.PreStop.Sleep != nil {
                        inUse = true
                        return false
                }
                if c.Lifecycle.PostStart != nil && c.Lifecycle.PostStart.Sleep != nil {
                        inUse = true
                        return false
                }
                return true
        })
        return inUse
}

func podLifecycleSleepActionZeroValueInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        var inUse bool
        VisitContainers(podSpec, AllContainers, func(c *api.Container, containerType ContainerType) bool {
                if c.Lifecycle == nil {
                        return true
                }
                if c.Lifecycle.PreStop != nil && c.Lifecycle.PreStop.Sleep != nil && c.Lifecycle.PreStop.Sleep.Seconds == 0 {
                        inUse = true
                        return false
                }
                if c.Lifecycle.PostStart != nil && c.Lifecycle.PostStart.Sleep != nil && c.Lifecycle.PostStart.Sleep.Seconds == 0 {
                        inUse = true
                        return false
                }
                return true
        })
        return inUse
}

// dropDisabledPodStatusFields removes disabled fields from the pod status
func dropDisabledPodStatusFields(podStatus, oldPodStatus *api.PodStatus, podSpec, oldPodSpec *api.PodSpec) {
        // the new status is always be non-nil
        if podStatus == nil {
                podStatus = &api.PodStatus{}
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.InPlacePodVerticalScaling) && !inPlacePodVerticalScalingInUse(oldPodSpec) {
                // Drop Resources fields
                dropResourcesField := func(csl []api.ContainerStatus) {
                        for i := range csl {
                                csl[i].Resources = nil
                        }
                }
                dropResourcesField(podStatus.ContainerStatuses)
                dropResourcesField(podStatus.InitContainerStatuses)
                dropResourcesField(podStatus.EphemeralContainerStatuses)

                // Drop AllocatedResources field
                dropAllocatedResourcesField := func(csl []api.ContainerStatus) {
                        for i := range csl {
                                csl[i].AllocatedResources = nil
                        }
                }
                dropAllocatedResourcesField(podStatus.ContainerStatuses)
                dropAllocatedResourcesField(podStatus.InitContainerStatuses)
                dropAllocatedResourcesField(podStatus.EphemeralContainerStatuses)
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.DynamicResourceAllocation) && !dynamicResourceAllocationInUse(oldPodSpec) {
                podStatus.ResourceClaimStatuses = nil
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.DRAExtendedResource) && !draExendedResourceInUse(oldPodStatus) {
                podStatus.ExtendedResourceClaimStatus = nil
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.RecursiveReadOnlyMounts) && !rroInUse(oldPodSpec) {
                for i := range podStatus.ContainerStatuses {
                        podStatus.ContainerStatuses[i].VolumeMounts = nil
                }
                for i := range podStatus.InitContainerStatuses {
                        podStatus.InitContainerStatuses[i].VolumeMounts = nil
                }
                for i := range podStatus.EphemeralContainerStatuses {
                        podStatus.EphemeralContainerStatuses[i].VolumeMounts = nil
                }
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.ResourceHealthStatus) {
                setAllocatedResourcesStatusToNil := func(csl []api.ContainerStatus) {
                        for i := range csl {
                                csl[i].AllocatedResourcesStatus = nil
                        }
                }
                setAllocatedResourcesStatusToNil(podStatus.ContainerStatuses)
                setAllocatedResourcesStatusToNil(podStatus.InitContainerStatuses)
                setAllocatedResourcesStatusToNil(podStatus.EphemeralContainerStatuses)
        }

        // drop ContainerStatus.User field to empty (disable SupplementalGroupsPolicy)
        if !utilfeature.DefaultFeatureGate.Enabled(features.SupplementalGroupsPolicy) && !supplementalGroupsPolicyInUse(oldPodSpec) {
                dropUserField := func(csl []api.ContainerStatus) {
                        for i := range csl {
                                csl[i].User = nil
                        }
                }
                dropUserField(podStatus.InitContainerStatuses)
                dropUserField(podStatus.ContainerStatuses)
                dropUserField(podStatus.EphemeralContainerStatuses)
        }

        if !utilfeature.DefaultFeatureGate.Enabled(features.PodObservedGenerationTracking) && !podObservedGenerationTrackingInUse(oldPodStatus) {
                podStatus.ObservedGeneration = 0
                for i := range podStatus.Conditions {
                        podStatus.Conditions[i].ObservedGeneration = 0
                }
        }
}

// dropDisabledDynamicResourceAllocationFields removes pod claim references from
// container specs and pod-level resource claims unless they are already used
// by the old pod spec.
func dropDisabledDynamicResourceAllocationFields(podSpec, oldPodSpec *api.PodSpec) {
        if !utilfeature.DefaultFeatureGate.Enabled(features.DynamicResourceAllocation) && !dynamicResourceAllocationInUse(oldPodSpec) {
                dropResourceClaimRequests(podSpec.Containers)
                dropResourceClaimRequests(podSpec.InitContainers)
                dropEphemeralResourceClaimRequests(podSpec.EphemeralContainers)
                podSpec.ResourceClaims = nil
        }
}

func draExendedResourceInUse(podStatus *api.PodStatus) bool {
        if podStatus != nil && podStatus.ExtendedResourceClaimStatus != nil {
                return true
        }
        return false
}

func dynamicResourceAllocationInUse(podSpec *api.PodSpec) bool {
        // We only need to check this field because the containers cannot have
        // resource requirements entries for claims without a corresponding
        // entry at the pod spec level.
        if podSpec != nil && len(podSpec.ResourceClaims) > 0 {
                return true
        }
        return false
}

func dropResourceClaimRequests(containers []api.Container) {
        for i := range containers {
                containers[i].Resources.Claims = nil
        }
}

func dropEphemeralResourceClaimRequests(containers []api.EphemeralContainer) {
        for i := range containers {
                containers[i].Resources.Claims = nil
        }
}

// dropDisabledProcMountField removes disabled fields from PodSpec related
// to ProcMount only if it is not already used by the old spec
func dropDisabledProcMountField(podSpec, oldPodSpec *api.PodSpec) {
        if !utilfeature.DefaultFeatureGate.Enabled(features.ProcMountType) && !procMountInUse(oldPodSpec) {
                defaultProcMount := api.DefaultProcMount
                VisitContainers(podSpec, AllContainers, func(c *api.Container, containerType ContainerType) bool {
                        if c.SecurityContext != nil && c.SecurityContext.ProcMount != nil {
                                // The ProcMount field was improperly forced to non-nil in 1.12.
                                // If the feature is disabled, and the existing object is not using any non-default values, and the ProcMount field is present in the incoming object, force to the default value.
                                // Note: we cannot force the field to nil when the feature is disabled because it causes a diff against previously persisted data.
                                c.SecurityContext.ProcMount = &defaultProcMount
                        }
                        return true
                })
        }
}

// dropDisabledNodeInclusionPolicyFields removes disabled fields from PodSpec related
// to NodeInclusionPolicy only if it is not used by the old spec.
func dropDisabledNodeInclusionPolicyFields(podSpec, oldPodSpec *api.PodSpec) {
        if !utilfeature.DefaultFeatureGate.Enabled(features.NodeInclusionPolicyInPodTopologySpread) && podSpec != nil {
                if !nodeTaintsPolicyInUse(oldPodSpec) {
                        for i := range podSpec.TopologySpreadConstraints {
                                podSpec.TopologySpreadConstraints[i].NodeTaintsPolicy = nil
                        }
                }
                if !nodeAffinityPolicyInUse(oldPodSpec) {
                        for i := range podSpec.TopologySpreadConstraints {
                                podSpec.TopologySpreadConstraints[i].NodeAffinityPolicy = nil
                        }
                }
        }
}

// dropDisabledMatchLabelKeysFieldInPodAffinity removes disabled fields from PodSpec related
// to MatchLabelKeys in required/preferred PodAffinity/PodAntiAffinity only if it is not already used by the old spec.
func dropDisabledMatchLabelKeysFieldInPodAffinity(podSpec, oldPodSpec *api.PodSpec) {
        if podSpec == nil || podSpec.Affinity == nil || utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodAffinity) || matchLabelKeysFieldInPodAffinityInUse(oldPodSpec) {
                return
        }

        if affinity := podSpec.Affinity.PodAffinity; affinity != nil {
                dropMatchLabelKeysFieldInPodAffnityTerm(affinity.RequiredDuringSchedulingIgnoredDuringExecution)
                dropMatchLabelKeysFieldInWeightedPodAffnityTerm(affinity.PreferredDuringSchedulingIgnoredDuringExecution)
        }
        if antiaffinity := podSpec.Affinity.PodAntiAffinity; antiaffinity != nil {
                dropMatchLabelKeysFieldInPodAffnityTerm(antiaffinity.RequiredDuringSchedulingIgnoredDuringExecution)
                dropMatchLabelKeysFieldInWeightedPodAffnityTerm(antiaffinity.PreferredDuringSchedulingIgnoredDuringExecution)
        }
}

// dropDisabledMatchLabelKeysFieldInTopologySpread removes disabled fields from PodSpec related
// to MatchLabelKeys in TopologySpread only if it is not already used by the old spec.
func dropDisabledMatchLabelKeysFieldInTopologySpread(podSpec, oldPodSpec *api.PodSpec) {
        if !utilfeature.DefaultFeatureGate.Enabled(features.MatchLabelKeysInPodTopologySpread) && !matchLabelKeysInTopologySpreadInUse(oldPodSpec) {
                for i := range podSpec.TopologySpreadConstraints {
                        podSpec.TopologySpreadConstraints[i].MatchLabelKeys = nil
                }
        }
}

// dropMatchLabelKeysFieldInWeightedPodAffnityTerm removes MatchLabelKeys and MismatchLabelKeys fields from WeightedPodAffinityTerm
func dropMatchLabelKeysFieldInWeightedPodAffnityTerm(terms []api.WeightedPodAffinityTerm) {
        for i := range terms {
                terms[i].PodAffinityTerm.MatchLabelKeys = nil
                terms[i].PodAffinityTerm.MismatchLabelKeys = nil
        }
}

// dropMatchLabelKeysFieldInPodAffnityTerm removes MatchLabelKeys and MismatchLabelKeys fields from PodAffinityTerm
func dropMatchLabelKeysFieldInPodAffnityTerm(terms []api.PodAffinityTerm) {
        for i := range terms {
                terms[i].MatchLabelKeys = nil
                terms[i].MismatchLabelKeys = nil
        }
}

// matchLabelKeysFieldInPodAffinityInUse returns true if given affinityTerms have MatchLabelKeys field set.
func matchLabelKeysFieldInPodAffinityInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil || podSpec.Affinity == nil {
                return false
        }

        if affinity := podSpec.Affinity.PodAffinity; affinity != nil {
                for _, c := range affinity.RequiredDuringSchedulingIgnoredDuringExecution {
                        if len(c.MatchLabelKeys) > 0 || len(c.MismatchLabelKeys) > 0 {
                                return true
                        }
                }

                for _, c := range affinity.PreferredDuringSchedulingIgnoredDuringExecution {
                        if len(c.PodAffinityTerm.MatchLabelKeys) > 0 || len(c.PodAffinityTerm.MismatchLabelKeys) > 0 {
                                return true
                        }
                }
        }

        if antiAffinity := podSpec.Affinity.PodAntiAffinity; antiAffinity != nil {
                for _, c := range antiAffinity.RequiredDuringSchedulingIgnoredDuringExecution {
                        if len(c.MatchLabelKeys) > 0 || len(c.MismatchLabelKeys) > 0 {
                                return true
                        }
                }

                for _, c := range antiAffinity.PreferredDuringSchedulingIgnoredDuringExecution {
                        if len(c.PodAffinityTerm.MatchLabelKeys) > 0 || len(c.PodAffinityTerm.MismatchLabelKeys) > 0 {
                                return true
                        }
                }
        }

        return false
}

// matchLabelKeysInTopologySpreadInUse returns true if the pod spec is non-nil
// and has MatchLabelKeys field set in TopologySpreadConstraints.
func matchLabelKeysInTopologySpreadInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }

        for _, c := range podSpec.TopologySpreadConstraints {
                if len(c.MatchLabelKeys) > 0 {
                        return true
                }
        }
        return false
}

// nodeAffinityPolicyInUse returns true if the pod spec is non-nil and has NodeAffinityPolicy field set
// in TopologySpreadConstraints
func nodeAffinityPolicyInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        for _, c := range podSpec.TopologySpreadConstraints {
                if c.NodeAffinityPolicy != nil {
                        return true
                }
        }
        return false
}

// nodeTaintsPolicyInUse returns true if the pod spec is non-nil and has NodeTaintsPolicy field set
// in TopologySpreadConstraints
func nodeTaintsPolicyInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        for _, c := range podSpec.TopologySpreadConstraints {
                if c.NodeTaintsPolicy != nil {
                        return true
                }
        }
        return false
}

// hostUsersInUse returns true if the pod spec has spec.hostUsers field set.
func hostUsersInUse(podSpec *api.PodSpec) bool {
        return podSpec != nil && podSpec.SecurityContext != nil && podSpec.SecurityContext.HostUsers != nil
}

func supplementalGroupsPolicyInUse(podSpec *api.PodSpec) bool {
        return podSpec != nil && podSpec.SecurityContext != nil && podSpec.SecurityContext.SupplementalGroupsPolicy != nil
}

func podObservedGenerationTrackingInUse(podStatus *api.PodStatus) bool {
        if podStatus == nil {
                return false
        }

        if podStatus.ObservedGeneration != 0 {
                return true
        }

        for _, condition := range podStatus.Conditions {
                if condition.ObservedGeneration != 0 {
                        return true
                }
        }

        return false
}

// podLevelResourcesInUse returns true if pod-spec is non-nil and Resources field at
// pod-level has non-empty Requests or Limits.
func podLevelResourcesInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }

        if podSpec.Resources == nil {
                return false
        }

        if len(podSpec.Resources.Requests) > 0 {
                return true
        }

        if len(podSpec.Resources.Limits) > 0 {
                return true
        }

        return false
}

// inPlacePodVerticalScalingInUse returns true if pod spec is non-nil and ResizePolicy is set
func inPlacePodVerticalScalingInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        var inUse bool
        containersMask := Containers | InitContainers
        VisitContainers(podSpec, containersMask, func(c *api.Container, containerType ContainerType) bool {
                if len(c.ResizePolicy) > 0 {
                        inUse = true
                        return false
                }
                return true
        })
        return inUse
}

// procMountInUse returns true if the pod spec is non-nil and has a SecurityContext's ProcMount field set to a non-default value
func procMountInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }

        var inUse bool
        VisitContainers(podSpec, AllContainers, func(c *api.Container, containerType ContainerType) bool {
                if c.SecurityContext == nil || c.SecurityContext.ProcMount == nil {
                        return true
                }
                if *c.SecurityContext.ProcMount != api.DefaultProcMount {
                        inUse = true
                        return false
                }
                return true
        })

        return inUse
}

// restartableInitContainersInUse returns true if the pod spec is non-nil and
// it has any init container with ContainerRestartPolicyAlways.
func restartableInitContainersInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        var inUse bool
        VisitContainers(podSpec, InitContainers, func(c *api.Container, containerType ContainerType) bool {
                if c.RestartPolicy != nil && *c.RestartPolicy == api.ContainerRestartPolicyAlways {
                        inUse = true
                        return false
                }
                return true
        })
        return inUse
}

func clusterTrustBundleProjectionInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        for _, v := range podSpec.Volumes {
                if v.Projected == nil {
                        continue
                }

                for _, s := range v.Projected.Sources {
                        if s.ClusterTrustBundle != nil {
                                return true
                        }
                }
        }

        return false
}

func rroInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        var inUse bool
        VisitContainers(podSpec, AllContainers, func(c *api.Container, _ ContainerType) bool {
                for _, f := range c.VolumeMounts {
                        if f.RecursiveReadOnly != nil {
                                inUse = true
                                return false
                        }
                }
                return true
        })
        return inUse
}

func dropDisabledClusterTrustBundleProjection(podSpec, oldPodSpec *api.PodSpec) {
        if utilfeature.DefaultFeatureGate.Enabled(features.ClusterTrustBundleProjection) {
                return
        }
        if podSpec == nil {
                return
        }

        // If the pod was already using it, it can keep using it.
        if clusterTrustBundleProjectionInUse(oldPodSpec) {
                return
        }

        for i := range podSpec.Volumes {
                if podSpec.Volumes[i].Projected == nil {
                        continue
                }

                for j := range podSpec.Volumes[i].Projected.Sources {
                        podSpec.Volumes[i].Projected.Sources[j].ClusterTrustBundle = nil
                }
        }
}

func podCertificateProjectionInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        for _, v := range podSpec.Volumes {
                if v.Projected == nil {
                        continue
                }

                for _, s := range v.Projected.Sources {
                        if s.PodCertificate != nil {
                                return true
                        }
                }
        }

        return false
}

func dropDisabledPodCertificateProjection(podSpec, oldPodSpec *api.PodSpec) {
        if utilfeature.DefaultFeatureGate.Enabled(features.PodCertificateRequest) {
                return
        }
        if podSpec == nil {
                return
        }

        // If the pod was already using it, it can keep using it.
        if podCertificateProjectionInUse(oldPodSpec) {
                return
        }

        for i := range podSpec.Volumes {
                if podSpec.Volumes[i].Projected == nil {
                        continue
                }

                for j := range podSpec.Volumes[i].Projected.Sources {
                        podSpec.Volumes[i].Projected.Sources[j].PodCertificate = nil
                }
        }
}

func hasInvalidLabelValueInAffinitySelector(spec *api.PodSpec) bool {
        if spec.Affinity != nil {
                if spec.Affinity.PodAffinity != nil {
                        for _, term := range spec.Affinity.PodAffinity.RequiredDuringSchedulingIgnoredDuringExecution {
                                allErrs := apivalidation.ValidatePodAffinityTermSelector(term, false, nil)
                                if len(allErrs) != 0 {
                                        return true
                                }
                        }
                        for _, term := range spec.Affinity.PodAffinity.PreferredDuringSchedulingIgnoredDuringExecution {
                                allErrs := apivalidation.ValidatePodAffinityTermSelector(term.PodAffinityTerm, false, nil)
                                if len(allErrs) != 0 {
                                        return true
                                }
                        }
                }
                if spec.Affinity.PodAntiAffinity != nil {
                        for _, term := range spec.Affinity.PodAntiAffinity.RequiredDuringSchedulingIgnoredDuringExecution {
                                allErrs := apivalidation.ValidatePodAffinityTermSelector(term, false, nil)
                                if len(allErrs) != 0 {
                                        return true
                                }
                        }
                        for _, term := range spec.Affinity.PodAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution {
                                allErrs := apivalidation.ValidatePodAffinityTermSelector(term.PodAffinityTerm, false, nil)
                                if len(allErrs) != 0 {
                                        return true
                                }
                        }
                }
        }
        return false
}

// IsRestartableInitContainer returns true if the container has ContainerRestartPolicyAlways.
// This function is not checking if the container passed to it is indeed an init container.
// It is just checking if the container restart policy has been set to always.
func IsRestartableInitContainer(initContainer *api.Container) bool {
        if initContainer == nil || initContainer.RestartPolicy == nil {
                return false
        }
        return *initContainer.RestartPolicy == api.ContainerRestartPolicyAlways
}

func hasInvalidLabelValueInRequiredNodeAffinity(spec *api.PodSpec) bool {
        if spec == nil ||
                spec.Affinity == nil ||
                spec.Affinity.NodeAffinity == nil ||
                spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution == nil {
                return false
        }
        return helper.HasInvalidLabelValueInNodeSelectorTerms(spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms)
}

// KEP: https://kep.k8s.io/4639
func dropImageVolumes(podSpec, oldPodSpec *api.PodSpec) {
        if utilfeature.DefaultFeatureGate.Enabled(features.ImageVolume) || imageVolumesInUse(oldPodSpec) {
                return
        }

        imageVolumeNames := sets.New[string]()
        var newVolumes []api.Volume
        for _, v := range podSpec.Volumes {
                if v.Image != nil {
                        imageVolumeNames.Insert(v.Name)
                        continue
                }
                newVolumes = append(newVolumes, v)
        }
        podSpec.Volumes = newVolumes

        dropVolumeMounts := func(givenMounts []api.VolumeMount) (newVolumeMounts []api.VolumeMount) {
                for _, m := range givenMounts {
                        if !imageVolumeNames.Has(m.Name) {
                                newVolumeMounts = append(newVolumeMounts, m)
                        }
                }
                return newVolumeMounts
        }

        for i, c := range podSpec.Containers {
                podSpec.Containers[i].VolumeMounts = dropVolumeMounts(c.VolumeMounts)
        }

        for i, c := range podSpec.InitContainers {
                podSpec.InitContainers[i].VolumeMounts = dropVolumeMounts(c.VolumeMounts)
        }

        for i, c := range podSpec.EphemeralContainers {
                podSpec.EphemeralContainers[i].VolumeMounts = dropVolumeMounts(c.VolumeMounts)
        }
}

func imageVolumesInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }

        for _, v := range podSpec.Volumes {
                if v.Image != nil {
                        return true
                }
        }

        return false
}

func dropSELinuxChangePolicy(podSpec, oldPodSpec *api.PodSpec) {
        if utilfeature.DefaultFeatureGate.Enabled(features.SELinuxChangePolicy) || seLinuxChangePolicyInUse(oldPodSpec) {
                return
        }
        if podSpec == nil || podSpec.SecurityContext == nil {
                return
        }
        podSpec.SecurityContext.SELinuxChangePolicy = nil
}

func seLinuxChangePolicyInUse(podSpec *api.PodSpec) bool {
        if podSpec == nil || podSpec.SecurityContext == nil {
                return false
        }
        return podSpec.SecurityContext.SELinuxChangePolicy != nil
}

func useOnlyRecursiveSELinuxChangePolicy(oldPodSpec *api.PodSpec) bool {
        if utilfeature.DefaultFeatureGate.Enabled(features.SELinuxMount) {
                // All policies are allowed
                return false
        }

        if seLinuxChangePolicyInUse(oldPodSpec) {
                // The old pod spec has *any* policy: we need to keep that object update-able.
                return false
        }
        // No feature gate + no value in the old object -> only Recursive is allowed
        return true
}

func hasUserNamespacesWithVolumeDevices(podSpec *api.PodSpec) bool {
        if podSpec.SecurityContext == nil || podSpec.SecurityContext.HostUsers == nil || *podSpec.SecurityContext.HostUsers {
                return false
        }

        hasVolumeDevices := false
        VisitContainers(podSpec, AllContainers, func(c *api.Container, _ ContainerType) bool {
                if len(c.VolumeDevices) > 0 {
                        hasVolumeDevices = true
                        return false // stop iterating
                }
                return true // keep iterating
        })
        return hasVolumeDevices
}

// hasRestartableInitContainerResizePolicy returns true if the pod spec is non-nil and
// it has any init container with ContainerRestartPolicyAlways and non-nil ResizePolicy.
func hasRestartableInitContainerResizePolicy(podSpec *api.PodSpec) bool {
        if podSpec == nil {
                return false
        }
        for _, c := range podSpec.InitContainers {
                if IsRestartableInitContainer(&c) && len(c.ResizePolicy) > 0 {
                        return true
                }
        }
        return false
}

// HasAPIObjectReference returns true if a reference to an API object is found in the pod spec,
// along with the plural resource of the referenced API type, or an error if an unknown field is encountered.
func HasAPIObjectReference(pod *api.Pod) (bool, string, error) {
        if pod.Spec.ServiceAccountName != "" {
                return true, "serviceaccounts", nil
        }

        hasSecrets := false
        VisitPodSecretNames(pod, func(name string) (shouldContinue bool) { hasSecrets = true; return false }, AllContainers)
        if hasSecrets {
                return true, "secrets", nil
        }

        hasConfigMaps := false
        VisitPodConfigmapNames(pod, func(name string) (shouldContinue bool) { hasConfigMaps = true; return false }, AllContainers)
        if hasConfigMaps {
                return true, "configmaps", nil
        }

        if len(pod.Spec.ResourceClaims) > 0 {
                return true, "resourceclaims", nil
        }

        for _, v := range pod.Spec.Volumes {
                switch {
                case v.AWSElasticBlockStore != nil, v.AzureDisk != nil, v.CephFS != nil, v.Cinder != nil,
                        v.DownwardAPI != nil, v.EmptyDir != nil, v.FC != nil, v.FlexVolume != nil, v.Flocker != nil, v.GCEPersistentDisk != nil,
                        v.GitRepo != nil, v.HostPath != nil, v.Image != nil, v.ISCSI != nil, v.NFS != nil, v.PhotonPersistentDisk != nil,
                        v.PortworxVolume != nil, v.Quobyte != nil, v.RBD != nil, v.ScaleIO != nil, v.StorageOS != nil, v.VsphereVolume != nil:
                        continue
                case v.ConfigMap != nil:
                        return true, "configmaps (via configmap volumes)", nil
                case v.Secret != nil:
                        return true, "secrets (via secret volumes)", nil
                case v.CSI != nil:
                        return true, "csidrivers (via CSI volumes)", nil
                case v.Glusterfs != nil:
                        return true, "endpoints (via glusterFS volumes)", nil
                case v.PersistentVolumeClaim != nil:
                        return true, "persistentvolumeclaims", nil
                case v.Ephemeral != nil:
                        return true, "persistentvolumeclaims (via ephemeral volumes)", nil
                case v.AzureFile != nil:
                        return true, "secrets (via azureFile volumes)", nil
                case v.Projected != nil:
                        for _, s := range v.Projected.Sources {
                                // Reject projected volume sources that require the Kubernetes API
                                switch {
                                case s.ConfigMap != nil:
                                        return true, "configmaps (via projected volumes)", nil
                                case s.Secret != nil:
                                        return true, "secrets (via projected volumes)", nil
                                case s.ServiceAccountToken != nil:
                                        return true, "serviceaccounts (via projected volumes)", nil
                                case s.ClusterTrustBundle != nil:
                                        return true, "clustertrustbundles", nil
                                case s.PodCertificate != nil:
                                        return true, "podcertificates", nil
                                case s.DownwardAPI != nil:
                                        // Allow projected volume sources that don't require the Kubernetes API
                                        continue
                                default:
                                        // Reject unknown volume types
                                        return true, "", fmt.Errorf("unknown source for projected volume %q", v.Name)
                                }
                        }
                default:
                        return true, "", fmt.Errorf("unknown volume type for volume  %q", v.Name)
                }
        }

        return false, "", nil
}

// ApparmorFieldForAnnotation takes a pod annotation and returns the converted
// apparmor profile field.
func ApparmorFieldForAnnotation(annotation string) *api.AppArmorProfile {
        if annotation == api.DeprecatedAppArmorAnnotationValueUnconfined {
                return &api.AppArmorProfile{Type: api.AppArmorProfileTypeUnconfined}
        }

        if annotation == api.DeprecatedAppArmorAnnotationValueRuntimeDefault {
                return &api.AppArmorProfile{Type: api.AppArmorProfileTypeRuntimeDefault}
        }

        if strings.HasPrefix(annotation, api.DeprecatedAppArmorAnnotationValueLocalhostPrefix) {
                localhostProfile := strings.TrimPrefix(annotation, api.DeprecatedAppArmorAnnotationValueLocalhostPrefix)
                if localhostProfile != "" {
                        return &api.AppArmorProfile{
                                Type:             api.AppArmorProfileTypeLocalhost,
                                LocalhostProfile: &localhostProfile,
                        }
                }
        }

        // we can only reach this code path if the localhostProfile name has a zero
        // length or if the annotation has an unrecognized value
        return nil
}

func dropContainerRestartRules(podSpec *api.PodSpec) {
        if podSpec == nil {
                return
        }
        for i, c := range podSpec.InitContainers {
                if c.RestartPolicy != nil && *c.RestartPolicy != api.ContainerRestartPolicyAlways {
                        podSpec.InitContainers[i].RestartPolicy = nil
                }
                podSpec.InitContainers[i].RestartPolicyRules = nil
        }
        for i := range podSpec.Containers {
                podSpec.Containers[i].RestartPolicy = nil
                podSpec.Containers[i].RestartPolicyRules = nil
        }
        for i := range podSpec.EphemeralContainers {
                podSpec.EphemeralContainers[i].RestartPolicy = nil
                podSpec.EphemeralContainers[i].RestartPolicyRules = nil
        }
}

func containerRestartRulesInUse(oldPodSpec *api.PodSpec) bool {
        if oldPodSpec == nil {
                return false
        }
        for _, c := range oldPodSpec.InitContainers {
                if c.RestartPolicy != nil && *c.RestartPolicy != api.ContainerRestartPolicyAlways {
                        return true
                }
                if len(c.RestartPolicyRules) > 0 {
                        return true
                }
        }
        for _, c := range oldPodSpec.Containers {
                if c.RestartPolicy != nil {
                        return true
                }
        }
        return false
}

/*
Copyright 2021 The Kubernetes Authors.

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.
*/

package pod

import (
        "context"
        "fmt"
        "os"
        "strings"

        apiequality "k8s.io/apimachinery/pkg/api/equality"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/util/sets"
        "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        nodeapi "k8s.io/kubernetes/pkg/api/node"
        pvcutil "k8s.io/kubernetes/pkg/api/persistentvolumeclaim"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/core/pods"
        "k8s.io/kubernetes/pkg/features"
)

func GetWarningsForPod(ctx context.Context, pod, oldPod *api.Pod) []string {
        if pod == nil {
                return nil
        }

        var (
                oldSpec *api.PodSpec
                oldMeta *metav1.ObjectMeta
        )
        if oldPod != nil {
                oldSpec = &oldPod.Spec
                oldMeta = &oldPod.ObjectMeta
        }
        return warningsForPodSpecAndMeta(nil, &pod.Spec, &pod.ObjectMeta, oldSpec, oldMeta)
}

func GetWarningsForPodTemplate(ctx context.Context, fieldPath *field.Path, podTemplate, oldPodTemplate *api.PodTemplateSpec) []string {
        if podTemplate == nil {
                return nil
        }

        var (
                oldSpec *api.PodSpec
                oldMeta *metav1.ObjectMeta
        )
        if oldPodTemplate != nil {
                oldSpec = &oldPodTemplate.Spec
                oldMeta = &oldPodTemplate.ObjectMeta
        }
        return warningsForPodSpecAndMeta(fieldPath, &podTemplate.Spec, &podTemplate.ObjectMeta, oldSpec, oldMeta)
}

var deprecatedAnnotations = []struct {
        key     string
        prefix  string
        message string
}{
        {
                key:     `scheduler.alpha.kubernetes.io/critical-pod`,
                message: `non-functional in v1.16+; use the "priorityClassName" field instead`,
        },
        {
                key:     `security.alpha.kubernetes.io/sysctls`,
                message: `non-functional in v1.11+; use the "sysctls" field instead`,
        },
        {
                key:     `security.alpha.kubernetes.io/unsafe-sysctls`,
                message: `non-functional in v1.11+; use the "sysctls" field instead`,
        },
}

func warningsForPodSpecAndMeta(fieldPath *field.Path, podSpec *api.PodSpec, meta *metav1.ObjectMeta, oldPodSpec *api.PodSpec, oldMeta *metav1.ObjectMeta) []string {
        var warnings []string

        // use of deprecated node labels in selectors/affinity/topology
        for k := range podSpec.NodeSelector {
                if msg, deprecated := nodeapi.GetNodeLabelDeprecatedMessage(k); deprecated {
                        warnings = append(warnings, fmt.Sprintf("%s: %s", fieldPath.Child("spec", "nodeSelector").Key(k), msg))
                }
        }
        if podSpec.Affinity != nil && podSpec.Affinity.NodeAffinity != nil {
                n := podSpec.Affinity.NodeAffinity
                if n.RequiredDuringSchedulingIgnoredDuringExecution != nil {
                        termFldPath := fieldPath.Child("spec", "affinity", "nodeAffinity", "requiredDuringSchedulingIgnoredDuringExecution", "nodeSelectorTerms")
                        for i, term := range n.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms {
                                warnings = append(warnings, nodeapi.GetWarningsForNodeSelectorTerm(term, false, termFldPath.Index(i))...)
                        }
                }
                preferredFldPath := fieldPath.Child("spec", "affinity", "nodeAffinity", "preferredDuringSchedulingIgnoredDuringExecution")
                for i, term := range n.PreferredDuringSchedulingIgnoredDuringExecution {
                        warnings = append(warnings, nodeapi.GetWarningsForNodeSelectorTerm(term.Preference, true, preferredFldPath.Index(i).Child("preference"))...)
                }
        }
        for i, t := range podSpec.TopologySpreadConstraints {
                if msg, deprecated := nodeapi.GetNodeLabelDeprecatedMessage(t.TopologyKey); deprecated {
                        warnings = append(warnings, fmt.Sprintf(
                                "%s: %s is %s",
                                fieldPath.Child("spec", "topologySpreadConstraints").Index(i).Child("topologyKey"),
                                t.TopologyKey,
                                msg,
                        ))
                }

                // warn if labelSelector is empty which is no-match.
                if t.LabelSelector == nil {
                        warnings = append(warnings, fmt.Sprintf("%s: a null labelSelector results in matching no pod", fieldPath.Child("spec", "topologySpreadConstraints").Index(i).Child("labelSelector")))
                }
        }

        // use of deprecated annotations
        for _, deprecated := range deprecatedAnnotations {
                if _, exists := meta.Annotations[deprecated.key]; exists {
                        warnings = append(warnings, fmt.Sprintf("%s: %s", fieldPath.Child("metadata", "annotations").Key(deprecated.key), deprecated.message))
                }
                if len(deprecated.prefix) > 0 {
                        for k := range meta.Annotations {
                                if strings.HasPrefix(k, deprecated.prefix) {
                                        warnings = append(warnings, fmt.Sprintf("%s: %s", fieldPath.Child("metadata", "annotations").Key(k), deprecated.message))
                                        break
                                }
                        }
                }
        }

        // deprecated and removed volume plugins
        for i, v := range podSpec.Volumes {
                if v.PhotonPersistentDisk != nil {
                        warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.11, non-functional in v1.16+", fieldPath.Child("spec", "volumes").Index(i).Child("photonPersistentDisk")))
                }
                if v.GitRepo != nil {
                        if !utilfeature.DefaultFeatureGate.Enabled(features.GitRepoVolumeDriver) {
                                warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.11, and disabled by default in v1.33+", fieldPath.Child("spec", "volumes").Index(i).Child("gitRepo")))
                        } else {
                                warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.11", fieldPath.Child("spec", "volumes").Index(i).Child("gitRepo")))
                        }
                }
                if v.ScaleIO != nil {
                        warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.16, non-functional in v1.22+", fieldPath.Child("spec", "volumes").Index(i).Child("scaleIO")))
                }
                if v.Flocker != nil {
                        warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.22, non-functional in v1.25+", fieldPath.Child("spec", "volumes").Index(i).Child("flocker")))
                }
                if v.StorageOS != nil {
                        warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.22, non-functional in v1.25+", fieldPath.Child("spec", "volumes").Index(i).Child("storageOS")))
                }
                if v.Quobyte != nil {
                        warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.22, non-functional in v1.25+", fieldPath.Child("spec", "volumes").Index(i).Child("quobyte")))
                }
                if v.Glusterfs != nil {
                        warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.25, non-functional in v1.26+", fieldPath.Child("spec", "volumes").Index(i).Child("glusterfs")))
                }
                if v.Ephemeral != nil && v.Ephemeral.VolumeClaimTemplate != nil {
                        warnings = append(warnings, pvcutil.GetWarningsForPersistentVolumeClaimSpec(fieldPath.Child("spec", "volumes").Index(i).Child("ephemeral").Child("volumeClaimTemplate").Child("spec"), v.Ephemeral.VolumeClaimTemplate.Spec)...)
                }
                if v.CephFS != nil {
                        warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.28, non-functional in v1.31+", fieldPath.Child("spec", "volumes").Index(i).Child("cephfs")))
                }
                if v.RBD != nil {
                        warnings = append(warnings, fmt.Sprintf("%s: deprecated in v1.28, non-functional in v1.31+", fieldPath.Child("spec", "volumes").Index(i).Child("rbd")))
                }
        }

        if overlaps := warningsForOverlappingVirtualPaths(podSpec.Volumes); len(overlaps) > 0 {
                warnings = append(warnings, overlaps...)
        }

        // duplicate hostAliases (#91670, #58477)
        if len(podSpec.HostAliases) > 1 {
                items := sets.New[string]()
                for i, item := range podSpec.HostAliases {
                        if items.Has(item.IP) {
                                warnings = append(warnings, fmt.Sprintf("%s: duplicate ip %q", fieldPath.Child("spec", "hostAliases").Index(i).Child("ip"), item.IP))
                        } else {
                                items.Insert(item.IP)
                        }
                }
        }

        // duplicate imagePullSecrets (#91629, #58477)
        if len(podSpec.ImagePullSecrets) > 1 {
                items := sets.New[string]()
                for i, item := range podSpec.ImagePullSecrets {
                        if items.Has(item.Name) {
                                warnings = append(warnings, fmt.Sprintf("%s: duplicate name %q", fieldPath.Child("spec", "imagePullSecrets").Index(i).Child("name"), item.Name))
                        } else {
                                items.Insert(item.Name)
                        }
                }
        }
        // imagePullSecrets with empty name (#99454#issuecomment-787838112)
        for i, item := range podSpec.ImagePullSecrets {
                if len(item.Name) == 0 {
                        warnings = append(warnings, fmt.Sprintf("%s: invalid empty name %q", fieldPath.Child("spec", "imagePullSecrets").Index(i).Child("name"), item.Name))
                }
        }

        // fractional memory/ephemeral-storage requests/limits (#79950, #49442, #18538)
        if value, ok := podSpec.Overhead[api.ResourceMemory]; ok && value.MilliValue()%int64(1000) != int64(0) {
                warnings = append(warnings, fmt.Sprintf("%s: fractional byte value %q is invalid, must be an integer", fieldPath.Child("spec", "overhead").Key(string(api.ResourceMemory)), value.String()))
        }
        if value, ok := podSpec.Overhead[api.ResourceEphemeralStorage]; ok && value.MilliValue()%int64(1000) != int64(0) {
                warnings = append(warnings, fmt.Sprintf("%s: fractional byte value %q is invalid, must be an integer", fieldPath.Child("spec", "overhead").Key(string(api.ResourceEphemeralStorage)), value.String()))
        }

        // use of pod seccomp annotation without accompanying field
        if podSpec.SecurityContext == nil || podSpec.SecurityContext.SeccompProfile == nil {
                if _, exists := meta.Annotations[api.SeccompPodAnnotationKey]; exists {
                        warnings = append(warnings, fmt.Sprintf(`%s: non-functional in v1.27+; use the "seccompProfile" field instead`, fieldPath.Child("metadata", "annotations").Key(api.SeccompPodAnnotationKey)))
                }
        }
        var podAppArmorProfile *api.AppArmorProfile
        if podSpec.SecurityContext != nil {
                podAppArmorProfile = podSpec.SecurityContext.AppArmorProfile
        }

        pods.VisitContainersWithPath(podSpec, fieldPath.Child("spec"), func(c *api.Container, p *field.Path) bool {
                // use of container seccomp annotation without accompanying field
                if c.SecurityContext == nil || c.SecurityContext.SeccompProfile == nil {
                        if _, exists := meta.Annotations[api.SeccompContainerAnnotationKeyPrefix+c.Name]; exists {
                                warnings = append(warnings, fmt.Sprintf(`%s: non-functional in v1.27+; use the "seccompProfile" field instead`, fieldPath.Child("metadata", "annotations").Key(api.SeccompContainerAnnotationKeyPrefix+c.Name)))
                        }
                }

                // use of container AppArmor annotation without accompanying field

                isPodTemplate := fieldPath != nil // Pod warnings are emitted through applyAppArmorVersionSkew instead.
                hasAppArmorField := c.SecurityContext != nil && c.SecurityContext.AppArmorProfile != nil
                if isPodTemplate && !hasAppArmorField {
                        key := api.DeprecatedAppArmorAnnotationKeyPrefix + c.Name
                        if annotation, exists := meta.Annotations[key]; exists {
                                // Only warn if the annotation doesn't match the pod profile.
                                if podAppArmorProfile == nil || !apiequality.Semantic.DeepEqual(podAppArmorProfile, ApparmorFieldForAnnotation(annotation)) {
                                        warnings = append(warnings, fmt.Sprintf(`%s: deprecated since v1.30; use the "appArmorProfile" field instead`, fieldPath.Child("metadata", "annotations").Key(key)))
                                }
                        }
                }

                // fractional memory/ephemeral-storage requests/limits (#79950, #49442, #18538)
                if value, ok := c.Resources.Limits[api.ResourceMemory]; ok && value.MilliValue()%int64(1000) != int64(0) {
                        warnings = append(warnings, fmt.Sprintf("%s: fractional byte value %q is invalid, must be an integer", p.Child("resources", "limits").Key(string(api.ResourceMemory)), value.String()))
                }
                if value, ok := c.Resources.Requests[api.ResourceMemory]; ok && value.MilliValue()%int64(1000) != int64(0) {
                        warnings = append(warnings, fmt.Sprintf("%s: fractional byte value %q is invalid, must be an integer", p.Child("resources", "requests").Key(string(api.ResourceMemory)), value.String()))
                }
                if value, ok := c.Resources.Limits[api.ResourceEphemeralStorage]; ok && value.MilliValue()%int64(1000) != int64(0) {
                        warnings = append(warnings, fmt.Sprintf("%s: fractional byte value %q is invalid, must be an integer", p.Child("resources", "limits").Key(string(api.ResourceEphemeralStorage)), value.String()))
                }
                if value, ok := c.Resources.Requests[api.ResourceEphemeralStorage]; ok && value.MilliValue()%int64(1000) != int64(0) {
                        warnings = append(warnings, fmt.Sprintf("%s: fractional byte value %q is invalid, must be an integer", p.Child("resources", "requests").Key(string(api.ResourceEphemeralStorage)), value.String()))
                }

                // duplicate containers[*].env (#86163, #93266, #58477)
                if len(c.Env) > 1 {
                        items := sets.New[string]()
                        for i, item := range c.Env {
                                if items.Has(item.Name) {
                                        // a previous value exists, but it might be OK
                                        bad := false
                                        ref := fmt.Sprintf("$(%s)", item.Name) // what does a ref to this name look like
                                        // if we are replacing it with a valueFrom, warn
                                        if item.ValueFrom != nil {
                                                bad = true
                                        }
                                        // if this is X="$(X)", warn
                                        if item.Value == ref {
                                                bad = true
                                        }
                                        // if the new value does not contain a reference to the old
                                        // value (e.g. X="abc"; X="$(X)123"), warn
                                        if !strings.Contains(item.Value, ref) {
                                                bad = true
                                        }
                                        if bad {
                                                warnings = append(warnings, fmt.Sprintf("%s: hides previous definition of %q, which may be dropped when using apply", p.Child("env").Index(i), item.Name))
                                        }
                                } else {
                                        items.Insert(item.Name)
                                }
                        }
                }
                return true
        })

        type portBlock struct {
                field *field.Path
                port  api.ContainerPort
        }

        // Accumulate ports across all containers
        allPorts := map[string][]portBlock{}
        pods.VisitContainersWithPath(podSpec, fieldPath.Child("spec"), func(c *api.Container, fldPath *field.Path) bool {
                for i, port := range c.Ports {
                        if port.HostIP != "" && port.HostPort == 0 {
                                warnings = append(warnings, fmt.Sprintf("%s: hostIP set without hostPort: %+v",
                                        fldPath.Child("ports").Index(i), port))
                        }
                        k := fmt.Sprintf("%d/%s", port.ContainerPort, port.Protocol)
                        if others, found := allPorts[k]; found {
                                // Someone else has this protcol+port, but it still might not be a conflict.
                                for _, other := range others {
                                        if port.HostIP == other.port.HostIP && port.HostPort == other.port.HostPort {
                                                // Exactly-equal is obvious. Validation should already filter for this except when these are unspecified.
                                                warnings = append(warnings, fmt.Sprintf("%s: duplicate port definition with %s", fldPath.Child("ports").Index(i), other.field))
                                        } else if port.HostPort == 0 || other.port.HostPort == 0 {
                                                // HostPort = 0 is redundant with any other value, which is odd but not really dangerous.  HostIP doesn't matter here.
                                                warnings = append(warnings, fmt.Sprintf("%s: overlapping port definition with %s", fldPath.Child("ports").Index(i), other.field))
                                        } else if a, b := port.HostIP == "", other.port.HostIP == ""; port.HostPort == other.port.HostPort && ((a || b) && !(a && b)) {
                                                // If the HostPorts are the same and either HostIP is not specified while the other is not, the behavior is undefined.
                                                warnings = append(warnings, fmt.Sprintf("%s: dangerously ambiguous port definition with %s", fldPath.Child("ports").Index(i), other.field))
                                        }
                                }
                                allPorts[k] = append(allPorts[k], portBlock{field: fldPath.Child("ports").Index(i), port: port})
                        } else {
                                allPorts[k] = []portBlock{{field: fldPath.Child("ports").Index(i), port: port}}
                        }
                }
                return true
        })

        // Accumulate port names of containers and sidecar containers
        allPortsNames := map[string]*field.Path{}
        pods.VisitContainersWithPath(podSpec, fieldPath.Child("spec"), func(c *api.Container, fldPath *field.Path) bool {
                for i, port := range c.Ports {
                        if port.Name != "" {
                                if other, found := allPortsNames[port.Name]; found {
                                        warnings = append(warnings, fmt.Sprintf("%s: duplicate port name %q with %s, services and probes that select ports by name will use %s", fldPath.Child("ports").Index(i), port.Name, other, other))
                                } else {
                                        allPortsNames[port.Name] = fldPath.Child("ports").Index(i)
                                }
                        }
                }
                return true
        })

        // warn if the terminationGracePeriodSeconds is negative.
        if podSpec.TerminationGracePeriodSeconds != nil && *podSpec.TerminationGracePeriodSeconds < 0 {
                warnings = append(warnings, fmt.Sprintf("%s: must be >= 0; negative values are invalid and will be treated as 1", fieldPath.Child("spec", "terminationGracePeriodSeconds")))
        }

        if podSpec.Affinity != nil {
                if affinity := podSpec.Affinity.PodAffinity; affinity != nil {
                        warnings = append(warnings, warningsForPodAffinityTerms(affinity.RequiredDuringSchedulingIgnoredDuringExecution, fieldPath.Child("spec", "affinity", "podAffinity", "requiredDuringSchedulingIgnoredDuringExecution"))...)
                        warnings = append(warnings, warningsForWeightedPodAffinityTerms(affinity.PreferredDuringSchedulingIgnoredDuringExecution, fieldPath.Child("spec", "affinity", "podAffinity", "preferredDuringSchedulingIgnoredDuringExecution"))...)
                }
                if affinity := podSpec.Affinity.PodAntiAffinity; affinity != nil {
                        warnings = append(warnings, warningsForPodAffinityTerms(affinity.RequiredDuringSchedulingIgnoredDuringExecution, fieldPath.Child("spec", "affinity", "podAntiAffinity", "requiredDuringSchedulingIgnoredDuringExecution"))...)
                        warnings = append(warnings, warningsForWeightedPodAffinityTerms(affinity.PreferredDuringSchedulingIgnoredDuringExecution, fieldPath.Child("spec", "affinity", "podAntiAffinity", "preferredDuringSchedulingIgnoredDuringExecution"))...)
                }
        }

        // Deprecated IP address formats
        if podSpec.DNSConfig != nil {
                for i, ns := range podSpec.DNSConfig.Nameservers {
                        warnings = append(warnings, validation.GetWarningsForIP(fieldPath.Child("spec", "dnsConfig", "nameservers").Index(i), ns)...)
                }
        }
        for i, hostAlias := range podSpec.HostAliases {
                warnings = append(warnings, validation.GetWarningsForIP(fieldPath.Child("spec", "hostAliases").Index(i).Child("ip"), hostAlias.IP)...)
        }

        return warnings
}

func warningsForPodAffinityTerms(terms []api.PodAffinityTerm, fieldPath *field.Path) []string {
        var warnings []string
        for i, t := range terms {
                if t.LabelSelector == nil {
                        warnings = append(warnings, fmt.Sprintf("%s: a null labelSelector results in matching no pod", fieldPath.Index(i).Child("labelSelector")))
                }
        }
        return warnings
}

func warningsForWeightedPodAffinityTerms(terms []api.WeightedPodAffinityTerm, fieldPath *field.Path) []string {
        var warnings []string
        for i, t := range terms {
                // warn if labelSelector is empty which is no-match.
                if t.PodAffinityTerm.LabelSelector == nil {
                        warnings = append(warnings, fmt.Sprintf("%s: a null labelSelector results in matching no pod", fieldPath.Index(i).Child("podAffinityTerm", "labelSelector")))
                }
        }
        return warnings
}

// warningsForOverlappingVirtualPaths validates that there are no overlapping paths in single ConfigMapVolume, SecretVolume, DownwardAPIVolume and ProjectedVolume.
// A volume can try to load different keys to the same path which will result in overwriting of the value from the latest registered key
// Another possible scenario is when one of the path contains the other key path. Example:
// configMap:
//
//                name: myconfig
//                items:
//                  - key: key1
//                    path: path
//              - key: key2
//                        path: path/path2
//
// In such cases we either get `is directory` or 'file exists' error message.
func warningsForOverlappingVirtualPaths(volumes []api.Volume) []string {
        var warnings []string

        mkWarn := func(volName, volDesc, body string) string {
                return fmt.Sprintf("volume %q (%s): overlapping paths: %s", volName, volDesc, body)
        }

        for _, v := range volumes {
                if v.ConfigMap != nil && v.ConfigMap.Items != nil {
                        overlaps := checkVolumeMappingForOverlap(extractPaths(v.ConfigMap.Items, ""))
                        for _, ol := range overlaps {
                                warnings = append(warnings, mkWarn(v.Name, fmt.Sprintf("ConfigMap %q", v.ConfigMap.Name), ol))
                        }
                }

                if v.Secret != nil && v.Secret.Items != nil {
                        overlaps := checkVolumeMappingForOverlap(extractPaths(v.Secret.Items, ""))
                        for _, ol := range overlaps {
                                warnings = append(warnings, mkWarn(v.Name, fmt.Sprintf("Secret %q", v.Secret.SecretName), ol))
                        }
                }

                if v.DownwardAPI != nil && v.DownwardAPI.Items != nil {
                        overlaps := checkVolumeMappingForOverlap(extractPathsDownwardAPI(v.DownwardAPI.Items, ""))
                        for _, ol := range overlaps {
                                warnings = append(warnings, mkWarn(v.Name, "DownwardAPI", ol))
                        }
                }

                if v.Projected != nil {
                        var allPaths []pathAndSource

                        for _, source := range v.Projected.Sources {
                                if source == (api.VolumeProjection{}) {
                                        warnings = append(warnings, fmt.Sprintf("volume %q (Projected) has no sources provided", v.Name))
                                        continue
                                }

                                var sourcePaths []pathAndSource
                                switch {
                                case source.ConfigMap != nil && source.ConfigMap.Items != nil:
                                        sourcePaths = extractPaths(source.ConfigMap.Items, fmt.Sprintf("ConfigMap %q", source.ConfigMap.Name))
                                case source.Secret != nil && source.Secret.Items != nil:
                                        sourcePaths = extractPaths(source.Secret.Items, fmt.Sprintf("Secret %q", source.Secret.Name))
                                case source.DownwardAPI != nil && source.DownwardAPI.Items != nil:
                                        sourcePaths = extractPathsDownwardAPI(source.DownwardAPI.Items, "DownwardAPI")
                                case source.ServiceAccountToken != nil:
                                        sourcePaths = []pathAndSource{{source.ServiceAccountToken.Path, "ServiceAccountToken"}}
                                case source.ClusterTrustBundle != nil:
                                        name := ""
                                        if source.ClusterTrustBundle.Name != nil {
                                                name = *source.ClusterTrustBundle.Name
                                        } else {
                                                name = *source.ClusterTrustBundle.SignerName
                                        }
                                        sourcePaths = []pathAndSource{{source.ClusterTrustBundle.Path, fmt.Sprintf("ClusterTrustBundle %q", name)}}
                                case source.PodCertificate != nil:
                                        sourcePaths = []pathAndSource{}
                                        if len(source.PodCertificate.CertificateChainPath) != 0 {
                                                sourcePaths = append(sourcePaths, pathAndSource{source.PodCertificate.CertificateChainPath, "PodCertificate chain"})
                                        }
                                        if len(source.PodCertificate.KeyPath) != 0 {
                                                sourcePaths = append(sourcePaths, pathAndSource{source.PodCertificate.KeyPath, "PodCertificate key"})
                                        }
                                        if len(source.PodCertificate.CredentialBundlePath) != 0 {
                                                sourcePaths = append(sourcePaths, pathAndSource{source.PodCertificate.CredentialBundlePath, "PodCertificate credential bundle"})
                                        }
                                }

                                if len(sourcePaths) == 0 {
                                        continue
                                }

                                for _, ps := range sourcePaths {
                                        ps.path = strings.TrimRight(ps.path, string(os.PathSeparator))
                                        if collisions := checkForOverlap(allPaths, ps); len(collisions) > 0 {
                                                for _, c := range collisions {
                                                        warnings = append(warnings, mkWarn(v.Name, "Projected", fmt.Sprintf("%s with %s", ps.String(), c.String())))
                                                }
                                        }
                                        allPaths = append(allPaths, ps)
                                }
                        }
                }
        }
        return warnings
}

// this lets us track a path and where it came from, for better errors
type pathAndSource struct {
        path   string
        source string
}

func (ps pathAndSource) String() string {
        if ps.source != "" {
                return fmt.Sprintf("%q (%s)", ps.path, ps.source)
        }
        return fmt.Sprintf("%q", ps.path)
}

func extractPaths(mapping []api.KeyToPath, source string) []pathAndSource {
        result := make([]pathAndSource, 0, len(mapping))

        for _, v := range mapping {
                result = append(result, pathAndSource{v.Path, source})
        }
        return result
}

func extractPathsDownwardAPI(mapping []api.DownwardAPIVolumeFile, source string) []pathAndSource {
        result := make([]pathAndSource, 0, len(mapping))

        for _, v := range mapping {
                result = append(result, pathAndSource{v.Path, source})
        }
        return result
}

func checkVolumeMappingForOverlap(paths []pathAndSource) []string {
        pathSeparator := string(os.PathSeparator)
        var warnings []string
        var allPaths []pathAndSource

        for _, ps := range paths {
                ps.path = strings.TrimRight(ps.path, pathSeparator)
                if collisions := checkForOverlap(allPaths, ps); len(collisions) > 0 {
                        for _, c := range collisions {
                                warnings = append(warnings, fmt.Sprintf("%s with %s", ps.String(), c.String()))
                        }
                }
                allPaths = append(allPaths, ps)
        }

        return warnings
}

func checkForOverlap(haystack []pathAndSource, needle pathAndSource) []pathAndSource {
        pathSeparator := `/` // this check runs in the API server, use the OS-agnostic separator

        if needle.path == "" {
                return nil
        }

        var result []pathAndSource
        for _, item := range haystack {
                switch {
                case item.path == "":
                        continue
                case item == needle:
                        result = append(result, item)
                case strings.HasPrefix(item.path+pathSeparator, needle.path+pathSeparator):
                        result = append(result, item)
                case strings.HasPrefix(needle.path+pathSeparator, item.path+pathSeparator):
                        result = append(result, item)
                }
        }

        return result
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package service

import (
        "fmt"
        "strings"

        api "k8s.io/kubernetes/pkg/apis/core"
        utilnet "k8s.io/utils/net"
)

const (
        defaultLoadBalancerSourceRanges = "0.0.0.0/0"
)

// IsAllowAll checks whether the utilnet.IPNet allows traffic from 0.0.0.0/0
func IsAllowAll(ipnets utilnet.IPNetSet) bool {
        for _, s := range ipnets.StringSlice() {
                if s == "0.0.0.0/0" {
                        return true
                }
        }
        return false
}

// GetLoadBalancerSourceRanges first try to parse and verify LoadBalancerSourceRanges field from a service.
// If the field is not specified, turn to parse and verify the AnnotationLoadBalancerSourceRangesKey annotation from a service,
// extracting the source ranges to allow, and if not present returns a default (allow-all) value.
func GetLoadBalancerSourceRanges(service *api.Service) (utilnet.IPNetSet, error) {
        var ipnets utilnet.IPNetSet
        var err error
        // if SourceRange field is specified, ignore sourceRange annotation
        if len(service.Spec.LoadBalancerSourceRanges) > 0 {
                specs := service.Spec.LoadBalancerSourceRanges
                ipnets, err = utilnet.ParseIPNets(specs...)

                if err != nil {
                        return nil, fmt.Errorf("service.Spec.LoadBalancerSourceRanges: %v is not valid. Expecting a list of IP ranges. For example, 10.0.0.0/24. Error msg: %v", specs, err)
                }
        } else {
                val := service.Annotations[api.AnnotationLoadBalancerSourceRangesKey]
                val = strings.TrimSpace(val)
                if val == "" {
                        val = defaultLoadBalancerSourceRanges
                }
                specs := strings.Split(val, ",")
                ipnets, err = utilnet.ParseIPNets(specs...)
                if err != nil {
                        return nil, fmt.Errorf("%s: %s is not valid. Expecting a comma-separated list of source IP ranges. For example, 10.0.0.0/24,192.168.2.0/24", api.AnnotationLoadBalancerSourceRangesKey, val)
                }
        }
        return ipnets, nil
}

// ExternallyAccessible checks if service is externally accessible.
func ExternallyAccessible(service *api.Service) bool {
        return service.Spec.Type == api.ServiceTypeLoadBalancer ||
                service.Spec.Type == api.ServiceTypeNodePort ||
                (service.Spec.Type == api.ServiceTypeClusterIP && len(service.Spec.ExternalIPs) > 0)
}

// RequestsOnlyLocalTraffic checks if service requests OnlyLocal traffic.
func RequestsOnlyLocalTraffic(service *api.Service) bool {
        if service.Spec.Type != api.ServiceTypeLoadBalancer &&
                service.Spec.Type != api.ServiceTypeNodePort {
                return false
        }

        return service.Spec.ExternalTrafficPolicy == api.ServiceExternalTrafficPolicyLocal
}

// NeedsHealthCheck checks if service needs health check.
func NeedsHealthCheck(service *api.Service) bool {
        if service.Spec.Type != api.ServiceTypeLoadBalancer {
                return false
        }
        return RequestsOnlyLocalTraffic(service)
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package service

import (
        "fmt"

        utilvalidation "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/core/helper"
)

func GetWarningsForService(service, oldService *api.Service) []string {
        if service == nil {
                return nil
        }
        var warnings []string

        if _, ok := service.Annotations[api.DeprecatedAnnotationTopologyAwareHints]; ok {
                warnings = append(warnings, fmt.Sprintf("annotation %s is deprecated, please use %s instead", api.DeprecatedAnnotationTopologyAwareHints, api.AnnotationTopologyMode))
        }

        if helper.IsServiceIPSet(service) {
                for i, clusterIP := range service.Spec.ClusterIPs {
                        warnings = append(warnings, utilvalidation.GetWarningsForIP(field.NewPath("spec").Child("clusterIPs").Index(i), clusterIP)...)
                }
        }

        if isHeadlessService(service) {
                if service.Spec.LoadBalancerIP != "" {
                        warnings = append(warnings, "spec.loadBalancerIP is ignored for headless services")
                }
                if len(service.Spec.ExternalIPs) > 0 {
                        warnings = append(warnings, "spec.externalIPs is ignored for headless services")
                }
                if service.Spec.SessionAffinity != "" {
                        warnings = append(warnings, "spec.SessionAffinity is ignored for headless services")
                }
        }

        for i, externalIP := range service.Spec.ExternalIPs {
                warnings = append(warnings, utilvalidation.GetWarningsForIP(field.NewPath("spec").Child("externalIPs").Index(i), externalIP)...)
        }

        if len(service.Spec.LoadBalancerIP) > 0 {
                warnings = append(warnings, utilvalidation.GetWarningsForIP(field.NewPath("spec").Child("loadBalancerIP"), service.Spec.LoadBalancerIP)...)
        }

        for i, cidr := range service.Spec.LoadBalancerSourceRanges {
                warnings = append(warnings, utilvalidation.GetWarningsForCIDR(field.NewPath("spec").Child("loadBalancerSourceRanges").Index(i), cidr)...)
        }

        if service.Spec.Type == api.ServiceTypeExternalName && len(service.Spec.ExternalIPs) > 0 {
                warnings = append(warnings, fmt.Sprintf("spec.externalIPs is ignored when spec.type is %q", api.ServiceTypeExternalName))
        }
        if service.Spec.Type != api.ServiceTypeExternalName && service.Spec.ExternalName != "" {
                warnings = append(warnings, fmt.Sprintf("spec.externalName is ignored when spec.type is not %q", api.ServiceTypeExternalName))
        }

        return warnings
}

func isHeadlessService(service *api.Service) bool {
        return service != nil && service.Spec.Type == api.ServiceTypeClusterIP && service.Spec.ClusterIP == api.ClusterIPNone
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package testing

import (
        "testing"

        "k8s.io/apimachinery/pkg/fields"
        "k8s.io/apimachinery/pkg/runtime/schema"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
)

// TestSelectableFieldLabelConversionsOfKind verifies that given resource have field
// label conversion defined for each its selectable field.
// fields contains selectable fields of the resource.
// labelMap maps deprecated labels to their canonical names.
func TestSelectableFieldLabelConversionsOfKind(t *testing.T, apiVersion string, kind string, fields fields.Set, labelMap map[string]string) {
        badFieldLabels := []string{
                "name",
                ".name",
                "bad",
                "metadata",
                "foo.bar",
        }

        value := "value"

        gv, err := schema.ParseGroupVersion(apiVersion)
        if err != nil {
                t.Errorf("kind=%s: got unexpected error: %v", kind, err)
                return
        }
        gvk := gv.WithKind(kind)

        if len(fields) == 0 {
                t.Logf("no selectable fields for kind %q, skipping", kind)
        }
        for label := range fields {
                if label == "name" {
                        t.Logf("FIXME: \"name\" is deprecated by \"metadata.name\", it should be removed from selectable fields of kind=%s", kind)
                        continue
                }
                newLabel, newValue, err := legacyscheme.Scheme.ConvertFieldLabel(gvk, label, value)
                if err != nil {
                        t.Errorf("kind=%s label=%s: got unexpected error: %v", kind, label, err)
                } else {
                        expectedLabel := label
                        if l, exists := labelMap[label]; exists {
                                expectedLabel = l
                        }
                        if newLabel != expectedLabel {
                                t.Errorf("kind=%s label=%s: got unexpected label name (%q != %q)", kind, label, newLabel, expectedLabel)
                        }
                        if newValue != value {
                                t.Errorf("kind=%s label=%s: got unexpected new value (%q != %q)", kind, label, newValue, value)
                        }
                }
        }

        for _, label := range badFieldLabels {
                _, _, err := legacyscheme.Scheme.ConvertFieldLabel(gvk, label, "value")
                if err == nil {
                        t.Errorf("kind=%s label=%s: got unexpected non-error", kind, label)
                }
        }
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package testing

import (
        "fmt"

        "sigs.k8s.io/randfill"

        appsv1 "k8s.io/api/apps/v1"
        v1 "k8s.io/api/core/v1"
        apitesting "k8s.io/apimachinery/pkg/api/apitesting"
        "k8s.io/apimachinery/pkg/api/apitesting/fuzzer"
        metafuzzer "k8s.io/apimachinery/pkg/apis/meta/fuzzer"
        "k8s.io/apimachinery/pkg/runtime"
        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
        admissionregistrationfuzzer "k8s.io/kubernetes/pkg/apis/admissionregistration/fuzzer"
        "k8s.io/kubernetes/pkg/apis/apps"
        appsfuzzer "k8s.io/kubernetes/pkg/apis/apps/fuzzer"
        autoscalingfuzzer "k8s.io/kubernetes/pkg/apis/autoscaling/fuzzer"
        batchfuzzer "k8s.io/kubernetes/pkg/apis/batch/fuzzer"
        certificatesfuzzer "k8s.io/kubernetes/pkg/apis/certificates/fuzzer"
        api "k8s.io/kubernetes/pkg/apis/core"
        corefuzzer "k8s.io/kubernetes/pkg/apis/core/fuzzer"
        discoveryfuzzer "k8s.io/kubernetes/pkg/apis/discovery/fuzzer"
        extensionsfuzzer "k8s.io/kubernetes/pkg/apis/extensions/fuzzer"
        flowcontrolfuzzer "k8s.io/kubernetes/pkg/apis/flowcontrol/fuzzer"
        networkingfuzzer "k8s.io/kubernetes/pkg/apis/networking/fuzzer"
        policyfuzzer "k8s.io/kubernetes/pkg/apis/policy/fuzzer"
        rbacfuzzer "k8s.io/kubernetes/pkg/apis/rbac/fuzzer"
        resourcefuzzer "k8s.io/kubernetes/pkg/apis/resource/fuzzer"
        schedulingfuzzer "k8s.io/kubernetes/pkg/apis/scheduling/fuzzer"
        storagefuzzer "k8s.io/kubernetes/pkg/apis/storage/fuzzer"
)

// overrideGenericFuncs override some generic fuzzer funcs from k8s.io/apiserver in order to have more realistic
// values in a Kubernetes context.
func overrideGenericFuncs(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(j *runtime.Object, c randfill.Continue) {
                        // TODO: uncomment when round trip starts from a versioned object
                        if true { // c.Bool() {
                                *j = &runtime.Unknown{
                                        // We do not set TypeMeta here because it is not carried through a round trip
                                        Raw:         []byte(`{"apiVersion":"unknown.group/unknown","kind":"Something","someKey":"someValue"}`),
                                        ContentType: runtime.ContentTypeJSON,
                                }
                        } else {
                                types := []runtime.Object{&api.Pod{}, &api.ReplicationController{}}
                                t := types[c.Rand.Intn(len(types))]
                                c.Fill(t)
                                *j = t
                        }
                },
                func(r *runtime.RawExtension, c randfill.Continue) {
                        // Pick an arbitrary type and fuzz it
                        types := []runtime.Object{&api.Pod{}, &apps.Deployment{}, &api.Service{}}
                        obj := types[c.Rand.Intn(len(types))]
                        c.Fill(obj)

                        var codec runtime.Codec
                        switch obj.(type) {
                        case *apps.Deployment:
                                codec = apitesting.TestCodec(codecs, appsv1.SchemeGroupVersion)
                        default:
                                codec = apitesting.TestCodec(codecs, v1.SchemeGroupVersion)
                        }

                        // Convert the object to raw bytes
                        bytes, err := runtime.Encode(codec, obj)
                        if err != nil {
                                panic(fmt.Sprintf("Failed to encode object: %v", err))
                        }

                        // Set the bytes field on the RawExtension
                        r.Raw = bytes
                },
        }
}

// FuzzerFuncs is a list of fuzzer functions
var FuzzerFuncs = fuzzer.MergeFuzzerFuncs(
        overrideGenericFuncs,
        corefuzzer.Funcs,
        extensionsfuzzer.Funcs,
        appsfuzzer.Funcs,
        batchfuzzer.Funcs,
        autoscalingfuzzer.Funcs,
        rbacfuzzer.Funcs,
        policyfuzzer.Funcs,
        resourcefuzzer.Funcs,
        certificatesfuzzer.Funcs,
        admissionregistrationfuzzer.Funcs,
        storagefuzzer.Funcs,
        networkingfuzzer.Funcs,
        metafuzzer.Funcs,
        schedulingfuzzer.Funcs,
        discoveryfuzzer.Funcs,
        flowcontrolfuzzer.Funcs,
)

/*
Copyright 2025 The Kubernetes Authors.

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.
*/

package testing

import (
        "bytes"
        "sort"
        "strconv"
        "testing"

        k8sruntime "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
        runtimetest "k8s.io/apimachinery/pkg/runtime/testing"
        "k8s.io/apimachinery/pkg/util/validation/field"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
)

// VerifyVersionedValidationEquivalence tests that all versions of an API return equivalent validation errors.
func VerifyVersionedValidationEquivalence(t *testing.T, obj, old k8sruntime.Object, subresources ...string) {
        t.Helper()

        // Accumulate errors from all versioned validation, per version.
        all := map[string]field.ErrorList{}
        accumulate := func(t *testing.T, gv string, errs field.ErrorList) {
                all[gv] = errs
        }
        // Convert versioned object to internal format before validation.
        // runtimetest.RunValidationForEachVersion requires unversioned (internal) objects as input.
        internalObj, err := convertToInternal(t, legacyscheme.Scheme, obj)
        if err != nil {
                t.Fatal(err)
        }
        if internalObj == nil {
                return
        }
        if old == nil {
                runtimetest.RunValidationForEachVersion(t, legacyscheme.Scheme, []string{}, internalObj, accumulate, subresources...)
        } else {
                // Convert old versioned object to internal format before validation.
                // runtimetest.RunUpdateValidationForEachVersion requires unversioned (internal) objects as input.
                internalOld, err := convertToInternal(t, legacyscheme.Scheme, old)
                if err != nil {
                        t.Fatal(err)
                }
                if internalOld == nil {
                        return
                }
                runtimetest.RunUpdateValidationForEachVersion(t, legacyscheme.Scheme, []string{}, internalObj, internalOld, accumulate, subresources...)
        }

        // Make a copy so we can modify it.
        other := map[string]field.ErrorList{}
        // Index for nicer output.
        keys := []string{}
        for k, v := range all {
                other[k] = v
                keys = append(keys, k)
        }
        sort.Strings(keys)

        // Compare each lhs to each rhs.
        for _, lk := range keys {
                lv := all[lk]
                // remove lk since to prevent comparison to itself and because this
                // iteration will compare it to any version it has not yet been
                // compared to. e.g. [1, 2, 3] vs. [1, 2, 3] yields:
                //   1 vs. 2
                //   1 vs. 3
                //   2 vs. 3
                delete(other, lk)
                // don't compare to ourself
                for _, rk := range keys {
                        rv, found := other[rk]
                        if !found {
                                continue // done already
                        }
                        if len(lv) != len(rv) {
                                t.Errorf("different error count (%d vs. %d)\n%s: %v\n%s: %v", len(lv), len(rv), lk, fmtErrs(lv), rk, fmtErrs(rv))
                                continue
                        }
                        next := false
                        for i := range lv {
                                if l, r := lv[i], rv[i]; l.Type != r.Type || l.Detail != r.Detail {
                                        t.Errorf("different errors\n%s: %v\n%s: %v", lk, fmtErrs(lv), rk, fmtErrs(rv))
                                        next = true
                                        break
                                }
                        }
                        if next {
                                continue
                        }
                }
        }
}

// helper for nicer output
func fmtErrs(errs field.ErrorList) string {
        if len(errs) == 0 {
                return "<no errors>"
        }
        if len(errs) == 1 {
                return strconv.Quote(errs[0].Error())
        }
        buf := bytes.Buffer{}
        for _, e := range errs {
                buf.WriteString("\n")
                buf.WriteString(strconv.Quote(e.Error()))
        }

        return buf.String()
}

func convertToInternal(t *testing.T, scheme *k8sruntime.Scheme, obj k8sruntime.Object) (k8sruntime.Object, error) {
        t.Helper()

        gvks, _, err := scheme.ObjectKinds(obj)
        if err != nil {
                t.Fatal(err)
        }
        if len(gvks) == 0 {
                t.Fatal("no GVKs found for object")
        }
        gvk := gvks[0]
        if gvk.Version == k8sruntime.APIVersionInternal {
                return obj, nil
        }
        gvk.Version = k8sruntime.APIVersionInternal
        if !scheme.Recognizes(gvk) {
                t.Logf("no internal object found for GroupKind %s", gvk.GroupKind().String())
                return nil, nil
        }
        return scheme.ConvertToVersion(obj, schema.GroupVersion{Group: gvk.Group, Version: k8sruntime.APIVersionInternal})
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package pod

import (
        "iter"
        "time"

        v1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        "k8s.io/kubernetes/pkg/features"
)

// ContainerType signifies container type
type ContainerType int

const (
        // Containers is for normal containers
        Containers ContainerType = 1 << iota
        // InitContainers is for init containers
        InitContainers
        // EphemeralContainers is for ephemeral containers
        EphemeralContainers
)

// AllContainers specifies that all containers be visited
const AllContainers ContainerType = InitContainers | Containers | EphemeralContainers

// AllFeatureEnabledContainers returns a ContainerType mask which includes all container
// types except for the ones guarded by feature gate.
func AllFeatureEnabledContainers() ContainerType {
        return AllContainers
}

// ContainerVisitor is called with each container spec, and returns true
// if visiting should continue.
type ContainerVisitor func(container *v1.Container, containerType ContainerType) (shouldContinue bool)

// Visitor is called with each object name, and returns true if visiting should continue
type Visitor func(name string) (shouldContinue bool)

func skipEmptyNames(visitor Visitor) Visitor {
        return func(name string) bool {
                if len(name) == 0 {
                        // continue visiting
                        return true
                }
                // delegate to visitor
                return visitor(name)
        }
}

// VisitContainers invokes the visitor function with a pointer to every container
// spec in the given pod spec with type set in mask. If visitor returns false,
// visiting is short-circuited. VisitContainers returns true if visiting completes,
// false if visiting was short-circuited.
func VisitContainers(podSpec *v1.PodSpec, mask ContainerType, visitor ContainerVisitor) bool {
        for c, t := range ContainerIter(podSpec, mask) {
                if !visitor(c, t) {
                        return false
                }
        }
        return true
}

// ContainerIter returns an iterator over all containers in the given pod spec with a masked type.
// The iteration order is InitContainers, then main Containers, then EphemeralContainers.
func ContainerIter(podSpec *v1.PodSpec, mask ContainerType) iter.Seq2[*v1.Container, ContainerType] {
        return func(yield func(*v1.Container, ContainerType) bool) {
                if mask&InitContainers != 0 {
                        for i := range podSpec.InitContainers {
                                if !yield(&podSpec.InitContainers[i], InitContainers) {
                                        return
                                }
                        }
                }
                if mask&Containers != 0 {
                        for i := range podSpec.Containers {
                                if !yield(&podSpec.Containers[i], Containers) {
                                        return
                                }
                        }
                }
                if mask&EphemeralContainers != 0 {
                        for i := range podSpec.EphemeralContainers {
                                if !yield((*v1.Container)(&podSpec.EphemeralContainers[i].EphemeralContainerCommon), EphemeralContainers) {
                                        return
                                }
                        }
                }
        }
}

// VisitPodSecretNames invokes the visitor function with the name of every secret
// referenced by the pod spec. If visitor returns false, visiting is short-circuited.
// Transitive references (e.g. pod -> pvc -> pv -> secret) are not visited.
// Returns true if visiting completed, false if visiting was short-circuited.
func VisitPodSecretNames(pod *v1.Pod, visitor Visitor) bool {
        visitor = skipEmptyNames(visitor)
        for _, reference := range pod.Spec.ImagePullSecrets {
                if !visitor(reference.Name) {
                        return false
                }
        }
        VisitContainers(&pod.Spec, AllContainers, func(c *v1.Container, containerType ContainerType) bool {
                return visitContainerSecretNames(c, visitor)
        })
        var source *v1.VolumeSource

        for i := range pod.Spec.Volumes {
                source = &pod.Spec.Volumes[i].VolumeSource
                switch {
                case source.AzureFile != nil:
                        if len(source.AzureFile.SecretName) > 0 && !visitor(source.AzureFile.SecretName) {
                                return false
                        }
                case source.CephFS != nil:
                        if source.CephFS.SecretRef != nil && !visitor(source.CephFS.SecretRef.Name) {
                                return false
                        }
                case source.Cinder != nil:
                        if source.Cinder.SecretRef != nil && !visitor(source.Cinder.SecretRef.Name) {
                                return false
                        }
                case source.FlexVolume != nil:
                        if source.FlexVolume.SecretRef != nil && !visitor(source.FlexVolume.SecretRef.Name) {
                                return false
                        }
                case source.Projected != nil:
                        for j := range source.Projected.Sources {
                                if source.Projected.Sources[j].Secret != nil {
                                        if !visitor(source.Projected.Sources[j].Secret.Name) {
                                                return false
                                        }
                                }
                        }
                case source.RBD != nil:
                        if source.RBD.SecretRef != nil && !visitor(source.RBD.SecretRef.Name) {
                                return false
                        }
                case source.Secret != nil:
                        if !visitor(source.Secret.SecretName) {
                                return false
                        }
                case source.ScaleIO != nil:
                        if source.ScaleIO.SecretRef != nil && !visitor(source.ScaleIO.SecretRef.Name) {
                                return false
                        }
                case source.ISCSI != nil:
                        if source.ISCSI.SecretRef != nil && !visitor(source.ISCSI.SecretRef.Name) {
                                return false
                        }
                case source.StorageOS != nil:
                        if source.StorageOS.SecretRef != nil && !visitor(source.StorageOS.SecretRef.Name) {
                                return false
                        }
                case source.CSI != nil:
                        if source.CSI.NodePublishSecretRef != nil && !visitor(source.CSI.NodePublishSecretRef.Name) {
                                return false
                        }
                }
        }
        return true
}

// visitContainerSecretNames returns true unless the visitor returned false when invoked with a secret reference
func visitContainerSecretNames(container *v1.Container, visitor Visitor) bool {
        for _, env := range container.EnvFrom {
                if env.SecretRef != nil {
                        if !visitor(env.SecretRef.Name) {
                                return false
                        }
                }
        }
        for _, envVar := range container.Env {
                if envVar.ValueFrom != nil && envVar.ValueFrom.SecretKeyRef != nil {
                        if !visitor(envVar.ValueFrom.SecretKeyRef.Name) {
                                return false
                        }
                }
        }
        return true
}

// VisitPodConfigmapNames invokes the visitor function with the name of every configmap
// referenced by the pod spec. If visitor returns false, visiting is short-circuited.
// Transitive references (e.g. pod -> pvc -> pv -> secret) are not visited.
// Returns true if visiting completed, false if visiting was short-circuited.
func VisitPodConfigmapNames(pod *v1.Pod, visitor Visitor) bool {
        visitor = skipEmptyNames(visitor)
        VisitContainers(&pod.Spec, AllContainers, func(c *v1.Container, containerType ContainerType) bool {
                return visitContainerConfigmapNames(c, visitor)
        })
        var source *v1.VolumeSource
        for i := range pod.Spec.Volumes {
                source = &pod.Spec.Volumes[i].VolumeSource
                switch {
                case source.Projected != nil:
                        for j := range source.Projected.Sources {
                                if source.Projected.Sources[j].ConfigMap != nil {
                                        if !visitor(source.Projected.Sources[j].ConfigMap.Name) {
                                                return false
                                        }
                                }
                        }
                case source.ConfigMap != nil:
                        if !visitor(source.ConfigMap.Name) {
                                return false
                        }
                }
        }
        return true
}

// visitContainerConfigmapNames returns true unless the visitor returned false when invoked with a configmap reference
func visitContainerConfigmapNames(container *v1.Container, visitor Visitor) bool {
        for _, env := range container.EnvFrom {
                if env.ConfigMapRef != nil {
                        if !visitor(env.ConfigMapRef.Name) {
                                return false
                        }
                }
        }
        for _, envVar := range container.Env {
                if envVar.ValueFrom != nil && envVar.ValueFrom.ConfigMapKeyRef != nil {
                        if !visitor(envVar.ValueFrom.ConfigMapKeyRef.Name) {
                                return false
                        }
                }
        }
        return true
}

// GetContainerStatus extracts the status of container "name" from "statuses".
// It returns true if "name" exists, else returns false.
func GetContainerStatus(statuses []v1.ContainerStatus, name string) (v1.ContainerStatus, bool) {
        for i := range statuses {
                if statuses[i].Name == name {
                        return statuses[i], true
                }
        }
        return v1.ContainerStatus{}, false
}

// GetExistingContainerStatus extracts the status of container "name" from "statuses",
// It also returns if "name" exists.
func GetExistingContainerStatus(statuses []v1.ContainerStatus, name string) v1.ContainerStatus {
        status, _ := GetContainerStatus(statuses, name)
        return status
}

// GetIndexOfContainerStatus gets the index of status of container "name" from "statuses",
// It returns (index, true) if "name" exists, else returns (0, false).
func GetIndexOfContainerStatus(statuses []v1.ContainerStatus, name string) (int, bool) {
        for i := range statuses {
                if statuses[i].Name == name {
                        return i, true
                }
        }
        return 0, false
}

// IsPodAvailable returns true if a pod is available; false otherwise.
// Precondition for an available pod is that it must be ready. On top
// of that, there are two cases when a pod can be considered available:
// 1. minReadySeconds == 0, or
// 2. LastTransitionTime (is set) + minReadySeconds <= current time
func IsPodAvailable(pod *v1.Pod, minReadySeconds int32, now metav1.Time) bool {
        if !IsPodReady(pod) {
                return false
        }

        c := GetPodReadyCondition(pod.Status)
        minReadySecondsDuration := time.Duration(minReadySeconds) * time.Second
        if minReadySeconds == 0 || (!c.LastTransitionTime.IsZero() && c.LastTransitionTime.Add(minReadySecondsDuration).Compare(now.Time) <= 0) {
                return true
        }
        return false
}

// IsPodReady returns true if a pod is ready; false otherwise.
func IsPodReady(pod *v1.Pod) bool {
        return IsPodReadyConditionTrue(pod.Status)
}

// IsPodTerminal returns true if a pod is terminal, all containers are stopped and cannot ever regress.
func IsPodTerminal(pod *v1.Pod) bool {
        return IsPodPhaseTerminal(pod.Status.Phase)
}

// IsPodPhaseTerminal returns true if the pod's phase is terminal.
func IsPodPhaseTerminal(phase v1.PodPhase) bool {
        return phase == v1.PodFailed || phase == v1.PodSucceeded
}

// IsPodReadyConditionTrue returns true if a pod is ready; false otherwise.
func IsPodReadyConditionTrue(status v1.PodStatus) bool {
        condition := GetPodReadyCondition(status)
        return condition != nil && condition.Status == v1.ConditionTrue
}

// IsContainersReadyConditionTrue returns true if a pod is ready; false otherwise.
func IsContainersReadyConditionTrue(status v1.PodStatus) bool {
        condition := GetContainersReadyCondition(status)
        return condition != nil && condition.Status == v1.ConditionTrue
}

// GetPodReadyCondition extracts the pod ready condition from the given status and returns that.
// Returns nil if the condition is not present.
func GetPodReadyCondition(status v1.PodStatus) *v1.PodCondition {
        _, condition := GetPodCondition(&status, v1.PodReady)
        return condition
}

// GetContainersReadyCondition extracts the containers ready condition from the given status and returns that.
// Returns nil if the condition is not present.
func GetContainersReadyCondition(status v1.PodStatus) *v1.PodCondition {
        _, condition := GetPodCondition(&status, v1.ContainersReady)
        return condition
}

// GetPodCondition extracts the provided condition from the given status and returns that.
// Returns nil and -1 if the condition is not present, and the index of the located condition.
func GetPodCondition(status *v1.PodStatus, conditionType v1.PodConditionType) (int, *v1.PodCondition) {
        if status == nil {
                return -1, nil
        }
        return GetPodConditionFromList(status.Conditions, conditionType)
}

// GetPodConditionFromList extracts the provided condition from the given list of condition and
// returns the index of the condition and the condition. Returns -1 and nil if the condition is not present.
func GetPodConditionFromList(conditions []v1.PodCondition, conditionType v1.PodConditionType) (int, *v1.PodCondition) {
        if conditions == nil {
                return -1, nil
        }
        for i := range conditions {
                if conditions[i].Type == conditionType {
                        return i, &conditions[i]
                }
        }
        return -1, nil
}

// UpdatePodCondition updates existing pod condition or creates a new one. Sets LastTransitionTime to now if the
// status has changed.
// Returns true if pod condition has changed or has been added.
func UpdatePodCondition(status *v1.PodStatus, condition *v1.PodCondition) bool {
        condition.LastTransitionTime = metav1.Now()
        // Try to find this pod condition.
        conditionIndex, oldCondition := GetPodCondition(status, condition.Type)

        if oldCondition == nil {
                // We are adding new pod condition.
                status.Conditions = append(status.Conditions, *condition)
                return true
        }
        // We are updating an existing condition, so we need to check if it has changed.
        if condition.Status == oldCondition.Status {
                condition.LastTransitionTime = oldCondition.LastTransitionTime
        }

        isEqual := condition.Status == oldCondition.Status &&
                condition.Reason == oldCondition.Reason &&
                condition.Message == oldCondition.Message &&
                condition.LastProbeTime.Equal(&oldCondition.LastProbeTime) &&
                condition.LastTransitionTime.Equal(&oldCondition.LastTransitionTime)

        status.Conditions[conditionIndex] = *condition
        // Return true if one of the fields have changed.
        return !isEqual
}

// IsRestartableInitContainer returns true if the container has ContainerRestartPolicyAlways.
// This function is not checking if the container passed to it is indeed an init container.
// It is just checking if the container restart policy has been set to always.
func IsRestartableInitContainer(initContainer *v1.Container) bool {
        if initContainer == nil || initContainer.RestartPolicy == nil {
                return false
        }
        return *initContainer.RestartPolicy == v1.ContainerRestartPolicyAlways
}

// IsContainerRestartable returns true if the container can be restarted. A container can be
// restarted if it has a pod-level restart policy "Always" or "OnFailure" and not override by
// container-level restart policy, or a container-level restart policy "Always" or "OnFailure",
// or a container level restart rule with action "Restart".
func IsContainerRestartable(pod v1.PodSpec, container v1.Container) bool {
        if container.RestartPolicy != nil {
                for _, rule := range container.RestartPolicyRules {
                        if rule.Action == v1.ContainerRestartRuleActionRestart {
                                return true
                        }
                }
                return *container.RestartPolicy != v1.ContainerRestartPolicyNever
        }
        return pod.RestartPolicy != v1.RestartPolicyNever
}

// ContainerShouldRestart checks if a container should be restarted by its restart policy.
// First, the container-level restartPolicyRules are evaluated in order. An action is taken if any
// rules are matched. Second, the container-level restart policy is used. Lastly, if no container
// level policy are specified, pod-level restart policy is used.
func ContainerShouldRestart(container v1.Container, pod v1.PodSpec, exitCode int32) bool {
        if container.RestartPolicy != nil {
                rule, ok := findMatchingContainerRestartRule(container, exitCode)
                if ok {
                        switch rule.Action {
                        case v1.ContainerRestartRuleActionRestart:
                                return true
                        default:
                                // Do nothing, fallback to container-level restart policy.
                        }
                }

                // Check container-level restart policy if no rules matched.
                switch *container.RestartPolicy {
                case v1.ContainerRestartPolicyAlways:
                        return true
                case v1.ContainerRestartPolicyOnFailure:
                        return exitCode != 0
                case v1.ContainerRestartPolicyNever:
                        return false
                default:
                        // Do nothing, fallback to pod-level restart policy.
                }
        }

        switch pod.RestartPolicy {
        case v1.RestartPolicyAlways:
                return true
        case v1.RestartPolicyOnFailure:
                return exitCode != 0
        case v1.RestartPolicyNever:
                return false
        default:
                // Default policy is Always, so we return true here.
                return true
        }
}

// findMatchingContainerRestartRule returns a rule and true if the exitCode matched
// one of the restart rules for the given container. Returns and empty rule and
// false if no rules matched.
func findMatchingContainerRestartRule(container v1.Container, exitCode int32) (rule v1.ContainerRestartRule, found bool) {
        for _, rule := range container.RestartPolicyRules {
                if rule.ExitCodes != nil {
                        exitCodeMatched := false
                        for _, code := range rule.ExitCodes.Values {
                                if code == exitCode {
                                        exitCodeMatched = true
                                }
                        }
                        switch rule.ExitCodes.Operator {
                        case v1.ContainerRestartRuleOnExitCodesOpIn:
                                if exitCodeMatched {
                                        return rule, true
                                }
                        case v1.ContainerRestartRuleOnExitCodesOpNotIn:
                                if !exitCodeMatched {
                                        return rule, true
                                }
                        default:
                                // Do nothing, continue to the next rule.
                        }
                }
        }
        return v1.ContainerRestartRule{}, false
}

// CalculatePodStatusObservedGeneration calculates the observedGeneration for the pod status.
// This is used to track the generation of the pod that was observed by the kubelet.
// The observedGeneration is set to the pod's generation when the feature gate
// PodObservedGenerationTracking is enabled OR if status.observedGeneration is already set.
// This protects against an infinite loop of kubelet trying to clear the value after the FG is turned off, and
// the API server preserving existing values when an incoming update tries to clear it.
func CalculatePodStatusObservedGeneration(pod *v1.Pod) int64 {
        if pod.Status.ObservedGeneration != 0 || utilfeature.DefaultFeatureGate.Enabled(features.PodObservedGenerationTracking) {
                return pod.Generation
        }
        return 0
}

// CalculatePodConditionObservedGeneration calculates the observedGeneration for a particular pod condition.
// The observedGeneration is set to the pod's generation when the feature gate
// PodObservedGenerationTracking is enabled OR if condition[].observedGeneration is already set.
// This protects against an infinite loop of kubelet trying to clear the value after the FG is turned off, and
// the API server preserving existing values when an incoming update tries to clear it.
func CalculatePodConditionObservedGeneration(podStatus *v1.PodStatus, generation int64, conditionType v1.PodConditionType) int64 {
        if podStatus == nil {
                return 0
        }
        if utilfeature.DefaultFeatureGate.Enabled(features.PodObservedGenerationTracking) {
                return generation
        }
        for _, condition := range podStatus.Conditions {
                if condition.Type == conditionType && condition.ObservedGeneration != 0 {
                        return generation
                }
        }
        return 0
}

/*
Copyright 2014 The Kubernetes Authors.

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.
*/

package resource

import (
        "fmt"
        "math"
        "strconv"
        "strings"

        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/api/resource"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        resourcehelper "k8s.io/component-helpers/resource"
        "k8s.io/kubernetes/pkg/features"
)

// GetResourceRequestQuantity finds and returns the request quantity for a specific resource.
func GetResourceRequestQuantity(pod *v1.Pod, resourceName v1.ResourceName) resource.Quantity {
        requestQuantity := resource.Quantity{}

        switch resourceName {
        case v1.ResourceCPU:
                requestQuantity = resource.Quantity{Format: resource.DecimalSI}
        case v1.ResourceMemory, v1.ResourceStorage, v1.ResourceEphemeralStorage:
                requestQuantity = resource.Quantity{Format: resource.BinarySI}
        default:
                requestQuantity = resource.Quantity{Format: resource.DecimalSI}
        }

        // Supported pod level resources will be used instead of container level ones when available
        hasPodLevelResources := utilfeature.DefaultFeatureGate.Enabled(features.PodLevelResources) && resourcehelper.IsPodLevelResourcesSet(pod)

        if rQuantity, ok := resourcehelper.PodRequests(pod, resourcehelper.PodResourcesOptions{SkipContainerLevelResources: hasPodLevelResources, ExcludeOverhead: true})[resourceName]; ok {
                requestQuantity.Add(rQuantity)
        }

        // Add overhead for running a pod
        // to the total requests if the resource total is non-zero
        if pod.Spec.Overhead != nil {
                if podOverhead, ok := pod.Spec.Overhead[resourceName]; ok && !requestQuantity.IsZero() {
                        requestQuantity.Add(podOverhead)
                }
        }

        return requestQuantity
}

// GetResourceRequest finds and returns the request value for a specific resource.
func GetResourceRequest(pod *v1.Pod, resource v1.ResourceName) int64 {
        if resource == v1.ResourcePods {
                return 1
        }

        requestQuantity := GetResourceRequestQuantity(pod, resource)

        if resource == v1.ResourceCPU {
                return requestQuantity.MilliValue()
        }

        return requestQuantity.Value()
}

// ExtractResourceValueByContainerName extracts the value of a resource
// by providing container name
func ExtractResourceValueByContainerName(fs *v1.ResourceFieldSelector, pod *v1.Pod, containerName string) (string, error) {
        container, err := findContainerInPod(pod, containerName)
        if err != nil {
                return "", err
        }
        return ExtractContainerResourceValue(fs, container)
}

// ExtractResourceValueByContainerNameAndNodeAllocatable extracts the value of a resource
// by providing container name and node allocatable
func ExtractResourceValueByContainerNameAndNodeAllocatable(fs *v1.ResourceFieldSelector, pod *v1.Pod, containerName string, nodeAllocatable v1.ResourceList) (string, error) {
        realContainer, err := findContainerInPod(pod, containerName)
        if err != nil {
                return "", err
        }

        container := realContainer.DeepCopy()

        MergeContainerResourceLimits(container, nodeAllocatable)

        return ExtractContainerResourceValue(fs, container)
}

// ExtractContainerResourceValue extracts the value of a resource
// in an already known container
func ExtractContainerResourceValue(fs *v1.ResourceFieldSelector, container *v1.Container) (string, error) {
        divisor := resource.Quantity{}
        if divisor.Cmp(fs.Divisor) == 0 {
                divisor = resource.MustParse("1")
        } else {
                divisor = fs.Divisor
        }

        switch fs.Resource {
        case "limits.cpu":
                return convertResourceCPUToString(container.Resources.Limits.Cpu(), divisor)
        case "limits.memory":
                return convertResourceMemoryToString(container.Resources.Limits.Memory(), divisor)
        case "limits.ephemeral-storage":
                return convertResourceEphemeralStorageToString(container.Resources.Limits.StorageEphemeral(), divisor)
        case "requests.cpu":
                return convertResourceCPUToString(container.Resources.Requests.Cpu(), divisor)
        case "requests.memory":
                return convertResourceMemoryToString(container.Resources.Requests.Memory(), divisor)
        case "requests.ephemeral-storage":
                return convertResourceEphemeralStorageToString(container.Resources.Requests.StorageEphemeral(), divisor)
        }
        // handle extended standard resources with dynamic names
        // example: requests.hugepages-<pageSize> or limits.hugepages-<pageSize>
        if strings.HasPrefix(fs.Resource, "requests.") {
                resourceName := v1.ResourceName(strings.TrimPrefix(fs.Resource, "requests."))
                if IsHugePageResourceName(resourceName) {
                        return convertResourceHugePagesToString(container.Resources.Requests.Name(resourceName, resource.BinarySI), divisor)
                }
        }
        if strings.HasPrefix(fs.Resource, "limits.") {
                resourceName := v1.ResourceName(strings.TrimPrefix(fs.Resource, "limits."))
                if IsHugePageResourceName(resourceName) {
                        return convertResourceHugePagesToString(container.Resources.Limits.Name(resourceName, resource.BinarySI), divisor)
                }
        }
        return "", fmt.Errorf("unsupported container resource : %v", fs.Resource)
}

// convertResourceCPUToString converts cpu value to the format of divisor and returns
// ceiling of the value.
func convertResourceCPUToString(cpu *resource.Quantity, divisor resource.Quantity) (string, error) {
        c := int64(math.Ceil(float64(cpu.MilliValue()) / float64(divisor.MilliValue())))
        return strconv.FormatInt(c, 10), nil
}

// convertResourceMemoryToString converts memory value to the format of divisor and returns
// ceiling of the value.
func convertResourceMemoryToString(memory *resource.Quantity, divisor resource.Quantity) (string, error) {
        m := int64(math.Ceil(float64(memory.Value()) / float64(divisor.Value())))
        return strconv.FormatInt(m, 10), nil
}

// convertResourceHugePagesToString converts hugepages value to the format of divisor and returns
// ceiling of the value.
func convertResourceHugePagesToString(hugePages *resource.Quantity, divisor resource.Quantity) (string, error) {
        m := int64(math.Ceil(float64(hugePages.Value()) / float64(divisor.Value())))
        return strconv.FormatInt(m, 10), nil
}

// convertResourceEphemeralStorageToString converts ephemeral storage value to the format of divisor and returns
// ceiling of the value.
func convertResourceEphemeralStorageToString(ephemeralStorage *resource.Quantity, divisor resource.Quantity) (string, error) {
        m := int64(math.Ceil(float64(ephemeralStorage.Value()) / float64(divisor.Value())))
        return strconv.FormatInt(m, 10), nil
}

// findContainerInPod finds a container by its name in the provided pod
func findContainerInPod(pod *v1.Pod, containerName string) (*v1.Container, error) {
        for _, container := range pod.Spec.Containers {
                if container.Name == containerName {
                        return &container, nil
                }
        }
        for _, container := range pod.Spec.InitContainers {
                if container.Name == containerName {
                        return &container, nil
                }
        }
        return nil, fmt.Errorf("container %s not found", containerName)
}

// MergeContainerResourceLimits checks if a limit is applied for
// the container, and if not, it sets the limit to the passed resource list.
func MergeContainerResourceLimits(container *v1.Container,
        allocatable v1.ResourceList) {
        if container.Resources.Limits == nil {
                container.Resources.Limits = make(v1.ResourceList)
        }
        // NOTE: we exclude hugepages-* resources because hugepages are never overcommitted.
        // This means that the container always has a limit specified.
        for _, resource := range []v1.ResourceName{v1.ResourceCPU, v1.ResourceMemory, v1.ResourceEphemeralStorage} {
                if quantity, exists := container.Resources.Limits[resource]; !exists || quantity.IsZero() {
                        if cap, exists := allocatable[resource]; exists {
                                container.Resources.Limits[resource] = cap.DeepCopy()
                        }
                }
        }
}

// IsHugePageResourceName returns true if the resource name has the huge page
// resource prefix.
func IsHugePageResourceName(name v1.ResourceName) bool {
        return strings.HasPrefix(string(name), v1.ResourceHugePagesPrefix)
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package service

import (
        "fmt"
        "strings"

        v1 "k8s.io/api/core/v1"
        utilnet "k8s.io/utils/net"
)

const (
        defaultLoadBalancerSourceRanges = "0.0.0.0/0"
)

// IsAllowAll checks whether the utilnet.IPNet allows traffic from 0.0.0.0/0
func IsAllowAll(ipnets utilnet.IPNetSet) bool {
        for _, s := range ipnets.StringSlice() {
                if s == "0.0.0.0/0" {
                        return true
                }
        }
        return false
}

// GetLoadBalancerSourceRanges first try to parse and verify LoadBalancerSourceRanges field from a service.
// If the field is not specified, turn to parse and verify the AnnotationLoadBalancerSourceRangesKey annotation from a service,
// extracting the source ranges to allow, and if not present returns a default (allow-all) value.
func GetLoadBalancerSourceRanges(service *v1.Service) (utilnet.IPNetSet, error) {
        var ipnets utilnet.IPNetSet
        var err error
        // if SourceRange field is specified, ignore sourceRange annotation
        if len(service.Spec.LoadBalancerSourceRanges) > 0 {
                specs := service.Spec.LoadBalancerSourceRanges
                ipnets, err = utilnet.ParseIPNets(specs...)

                if err != nil {
                        return nil, fmt.Errorf("service.Spec.LoadBalancerSourceRanges: %v is not valid. Expecting a list of IP ranges. For example, 10.0.0.0/24. Error msg: %v", specs, err)
                }
        } else {
                val := service.Annotations[v1.AnnotationLoadBalancerSourceRangesKey]
                val = strings.TrimSpace(val)
                if val == "" {
                        val = defaultLoadBalancerSourceRanges
                }
                specs := strings.Split(val, ",")
                ipnets, err = utilnet.ParseIPNets(specs...)
                if err != nil {
                        return nil, fmt.Errorf("%s: %s is not valid. Expecting a comma-separated list of source IP ranges. For example, 10.0.0.0/24,192.168.2.0/24", v1.AnnotationLoadBalancerSourceRangesKey, val)
                }
        }
        return ipnets, nil
}

// ExternallyAccessible checks if service is externally accessible.
func ExternallyAccessible(service *v1.Service) bool {
        return service.Spec.Type == v1.ServiceTypeLoadBalancer ||
                service.Spec.Type == v1.ServiceTypeNodePort ||
                (service.Spec.Type == v1.ServiceTypeClusterIP && len(service.Spec.ExternalIPs) > 0)
}

// ExternalPolicyLocal checks if service is externally accessible and has ETP = Local.
func ExternalPolicyLocal(service *v1.Service) bool {
        if !ExternallyAccessible(service) {
                return false
        }
        return service.Spec.ExternalTrafficPolicy == v1.ServiceExternalTrafficPolicyLocal
}

// InternalPolicyLocal checks if service has ITP = Local.
func InternalPolicyLocal(service *v1.Service) bool {
        if service.Spec.InternalTrafficPolicy == nil {
                return false
        }
        return *service.Spec.InternalTrafficPolicy == v1.ServiceInternalTrafficPolicyLocal
}

// NeedsHealthCheck checks if service needs health check.
func NeedsHealthCheck(service *v1.Service) bool {
        if service.Spec.Type != v1.ServiceTypeLoadBalancer {
                return false
        }
        return ExternalPolicyLocal(service)
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

// Package install installs the experimental API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/admission"
        v1 "k8s.io/kubernetes/pkg/apis/admission/v1"
        "k8s.io/kubernetes/pkg/apis/admission/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(admission.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion))
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package admission

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "admission.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder the schema builder
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme handler to add items to the schema
        AddToScheme = SchemeBuilder.AddToScheme
)

func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &AdmissionReview{},
        )
        return nil
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

package v1

import (
        admissionv1 "k8s.io/api/admission/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name for this API.
const GroupName = "admission.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &admissionv1.SchemeBuilder
        // AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(RegisterDefaults)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        admissionv1 "k8s.io/api/admission/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        types "k8s.io/apimachinery/pkg/types"
        admission "k8s.io/kubernetes/pkg/apis/admission"
        authenticationv1 "k8s.io/kubernetes/pkg/apis/authentication/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*admissionv1.AdmissionRequest)(nil), (*admission.AdmissionRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AdmissionRequest_To_admission_AdmissionRequest(a.(*admissionv1.AdmissionRequest), b.(*admission.AdmissionRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admission.AdmissionRequest)(nil), (*admissionv1.AdmissionRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admission_AdmissionRequest_To_v1_AdmissionRequest(a.(*admission.AdmissionRequest), b.(*admissionv1.AdmissionRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionv1.AdmissionResponse)(nil), (*admission.AdmissionResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AdmissionResponse_To_admission_AdmissionResponse(a.(*admissionv1.AdmissionResponse), b.(*admission.AdmissionResponse), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admission.AdmissionResponse)(nil), (*admissionv1.AdmissionResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admission_AdmissionResponse_To_v1_AdmissionResponse(a.(*admission.AdmissionResponse), b.(*admissionv1.AdmissionResponse), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionv1.AdmissionReview)(nil), (*admission.AdmissionReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AdmissionReview_To_admission_AdmissionReview(a.(*admissionv1.AdmissionReview), b.(*admission.AdmissionReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admission.AdmissionReview)(nil), (*admissionv1.AdmissionReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admission_AdmissionReview_To_v1_AdmissionReview(a.(*admission.AdmissionReview), b.(*admissionv1.AdmissionReview), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_AdmissionRequest_To_admission_AdmissionRequest(in *admissionv1.AdmissionRequest, out *admission.AdmissionRequest, s conversion.Scope) error {
        out.UID = types.UID(in.UID)
        out.Kind = in.Kind
        out.Resource = in.Resource
        out.SubResource = in.SubResource
        out.RequestKind = (*metav1.GroupVersionKind)(unsafe.Pointer(in.RequestKind))
        out.RequestResource = (*metav1.GroupVersionResource)(unsafe.Pointer(in.RequestResource))
        out.RequestSubResource = in.RequestSubResource
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Operation = admission.Operation(in.Operation)
        if err := authenticationv1.Convert_v1_UserInfo_To_authentication_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.Object, &out.Object, s); err != nil {
                return err
        }
        if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.OldObject, &out.OldObject, s); err != nil {
                return err
        }
        out.DryRun = (*bool)(unsafe.Pointer(in.DryRun))
        if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.Options, &out.Options, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_AdmissionRequest_To_admission_AdmissionRequest is an autogenerated conversion function.
func Convert_v1_AdmissionRequest_To_admission_AdmissionRequest(in *admissionv1.AdmissionRequest, out *admission.AdmissionRequest, s conversion.Scope) error {
        return autoConvert_v1_AdmissionRequest_To_admission_AdmissionRequest(in, out, s)
}

func autoConvert_admission_AdmissionRequest_To_v1_AdmissionRequest(in *admission.AdmissionRequest, out *admissionv1.AdmissionRequest, s conversion.Scope) error {
        out.UID = types.UID(in.UID)
        out.Kind = in.Kind
        out.Resource = in.Resource
        out.SubResource = in.SubResource
        out.RequestKind = (*metav1.GroupVersionKind)(unsafe.Pointer(in.RequestKind))
        out.RequestResource = (*metav1.GroupVersionResource)(unsafe.Pointer(in.RequestResource))
        out.RequestSubResource = in.RequestSubResource
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Operation = admissionv1.Operation(in.Operation)
        if err := authenticationv1.Convert_authentication_UserInfo_To_v1_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&in.Object, &out.Object, s); err != nil {
                return err
        }
        if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&in.OldObject, &out.OldObject, s); err != nil {
                return err
        }
        out.DryRun = (*bool)(unsafe.Pointer(in.DryRun))
        if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&in.Options, &out.Options, s); err != nil {
                return err
        }
        return nil
}

// Convert_admission_AdmissionRequest_To_v1_AdmissionRequest is an autogenerated conversion function.
func Convert_admission_AdmissionRequest_To_v1_AdmissionRequest(in *admission.AdmissionRequest, out *admissionv1.AdmissionRequest, s conversion.Scope) error {
        return autoConvert_admission_AdmissionRequest_To_v1_AdmissionRequest(in, out, s)
}

func autoConvert_v1_AdmissionResponse_To_admission_AdmissionResponse(in *admissionv1.AdmissionResponse, out *admission.AdmissionResponse, s conversion.Scope) error {
        out.UID = types.UID(in.UID)
        out.Allowed = in.Allowed
        out.Result = (*metav1.Status)(unsafe.Pointer(in.Result))
        out.Patch = *(*[]byte)(unsafe.Pointer(&in.Patch))
        out.PatchType = (*admission.PatchType)(unsafe.Pointer(in.PatchType))
        out.AuditAnnotations = *(*map[string]string)(unsafe.Pointer(&in.AuditAnnotations))
        out.Warnings = *(*[]string)(unsafe.Pointer(&in.Warnings))
        return nil
}

// Convert_v1_AdmissionResponse_To_admission_AdmissionResponse is an autogenerated conversion function.
func Convert_v1_AdmissionResponse_To_admission_AdmissionResponse(in *admissionv1.AdmissionResponse, out *admission.AdmissionResponse, s conversion.Scope) error {
        return autoConvert_v1_AdmissionResponse_To_admission_AdmissionResponse(in, out, s)
}

func autoConvert_admission_AdmissionResponse_To_v1_AdmissionResponse(in *admission.AdmissionResponse, out *admissionv1.AdmissionResponse, s conversion.Scope) error {
        out.UID = types.UID(in.UID)
        out.Allowed = in.Allowed
        out.Result = (*metav1.Status)(unsafe.Pointer(in.Result))
        out.Patch = *(*[]byte)(unsafe.Pointer(&in.Patch))
        out.PatchType = (*admissionv1.PatchType)(unsafe.Pointer(in.PatchType))
        out.AuditAnnotations = *(*map[string]string)(unsafe.Pointer(&in.AuditAnnotations))
        out.Warnings = *(*[]string)(unsafe.Pointer(&in.Warnings))
        return nil
}

// Convert_admission_AdmissionResponse_To_v1_AdmissionResponse is an autogenerated conversion function.
func Convert_admission_AdmissionResponse_To_v1_AdmissionResponse(in *admission.AdmissionResponse, out *admissionv1.AdmissionResponse, s conversion.Scope) error {
        return autoConvert_admission_AdmissionResponse_To_v1_AdmissionResponse(in, out, s)
}

func autoConvert_v1_AdmissionReview_To_admission_AdmissionReview(in *admissionv1.AdmissionReview, out *admission.AdmissionReview, s conversion.Scope) error {
        if in.Request != nil {
                in, out := &in.Request, &out.Request
                *out = new(admission.AdmissionRequest)
                if err := Convert_v1_AdmissionRequest_To_admission_AdmissionRequest(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Request = nil
        }
        out.Response = (*admission.AdmissionResponse)(unsafe.Pointer(in.Response))
        return nil
}

// Convert_v1_AdmissionReview_To_admission_AdmissionReview is an autogenerated conversion function.
func Convert_v1_AdmissionReview_To_admission_AdmissionReview(in *admissionv1.AdmissionReview, out *admission.AdmissionReview, s conversion.Scope) error {
        return autoConvert_v1_AdmissionReview_To_admission_AdmissionReview(in, out, s)
}

func autoConvert_admission_AdmissionReview_To_v1_AdmissionReview(in *admission.AdmissionReview, out *admissionv1.AdmissionReview, s conversion.Scope) error {
        if in.Request != nil {
                in, out := &in.Request, &out.Request
                *out = new(admissionv1.AdmissionRequest)
                if err := Convert_admission_AdmissionRequest_To_v1_AdmissionRequest(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Request = nil
        }
        out.Response = (*admissionv1.AdmissionResponse)(unsafe.Pointer(in.Response))
        return nil
}

// Convert_admission_AdmissionReview_To_v1_AdmissionReview is an autogenerated conversion function.
func Convert_admission_AdmissionReview_To_v1_AdmissionReview(in *admission.AdmissionReview, out *admissionv1.AdmissionReview, s conversion.Scope) error {
        return autoConvert_admission_AdmissionReview_To_v1_AdmissionReview(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        admissionv1beta1 "k8s.io/api/admission/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name for this API.
const GroupName = "admission.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &admissionv1beta1.SchemeBuilder
        // AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(RegisterDefaults)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        admissionv1beta1 "k8s.io/api/admission/v1beta1"
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        types "k8s.io/apimachinery/pkg/types"
        admission "k8s.io/kubernetes/pkg/apis/admission"
        authenticationv1 "k8s.io/kubernetes/pkg/apis/authentication/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*admissionv1beta1.AdmissionRequest)(nil), (*admission.AdmissionRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_AdmissionRequest_To_admission_AdmissionRequest(a.(*admissionv1beta1.AdmissionRequest), b.(*admission.AdmissionRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admission.AdmissionRequest)(nil), (*admissionv1beta1.AdmissionRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admission_AdmissionRequest_To_v1beta1_AdmissionRequest(a.(*admission.AdmissionRequest), b.(*admissionv1beta1.AdmissionRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionv1beta1.AdmissionResponse)(nil), (*admission.AdmissionResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_AdmissionResponse_To_admission_AdmissionResponse(a.(*admissionv1beta1.AdmissionResponse), b.(*admission.AdmissionResponse), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admission.AdmissionResponse)(nil), (*admissionv1beta1.AdmissionResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admission_AdmissionResponse_To_v1beta1_AdmissionResponse(a.(*admission.AdmissionResponse), b.(*admissionv1beta1.AdmissionResponse), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionv1beta1.AdmissionReview)(nil), (*admission.AdmissionReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_AdmissionReview_To_admission_AdmissionReview(a.(*admissionv1beta1.AdmissionReview), b.(*admission.AdmissionReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admission.AdmissionReview)(nil), (*admissionv1beta1.AdmissionReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admission_AdmissionReview_To_v1beta1_AdmissionReview(a.(*admission.AdmissionReview), b.(*admissionv1beta1.AdmissionReview), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_AdmissionRequest_To_admission_AdmissionRequest(in *admissionv1beta1.AdmissionRequest, out *admission.AdmissionRequest, s conversion.Scope) error {
        out.UID = types.UID(in.UID)
        out.Kind = in.Kind
        out.Resource = in.Resource
        out.SubResource = in.SubResource
        out.RequestKind = (*v1.GroupVersionKind)(unsafe.Pointer(in.RequestKind))
        out.RequestResource = (*v1.GroupVersionResource)(unsafe.Pointer(in.RequestResource))
        out.RequestSubResource = in.RequestSubResource
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Operation = admission.Operation(in.Operation)
        if err := authenticationv1.Convert_v1_UserInfo_To_authentication_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.Object, &out.Object, s); err != nil {
                return err
        }
        if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.OldObject, &out.OldObject, s); err != nil {
                return err
        }
        out.DryRun = (*bool)(unsafe.Pointer(in.DryRun))
        if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.Options, &out.Options, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_AdmissionRequest_To_admission_AdmissionRequest is an autogenerated conversion function.
func Convert_v1beta1_AdmissionRequest_To_admission_AdmissionRequest(in *admissionv1beta1.AdmissionRequest, out *admission.AdmissionRequest, s conversion.Scope) error {
        return autoConvert_v1beta1_AdmissionRequest_To_admission_AdmissionRequest(in, out, s)
}

func autoConvert_admission_AdmissionRequest_To_v1beta1_AdmissionRequest(in *admission.AdmissionRequest, out *admissionv1beta1.AdmissionRequest, s conversion.Scope) error {
        out.UID = types.UID(in.UID)
        out.Kind = in.Kind
        out.Resource = in.Resource
        out.SubResource = in.SubResource
        out.RequestKind = (*v1.GroupVersionKind)(unsafe.Pointer(in.RequestKind))
        out.RequestResource = (*v1.GroupVersionResource)(unsafe.Pointer(in.RequestResource))
        out.RequestSubResource = in.RequestSubResource
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Operation = admissionv1beta1.Operation(in.Operation)
        if err := authenticationv1.Convert_authentication_UserInfo_To_v1_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&in.Object, &out.Object, s); err != nil {
                return err
        }
        if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&in.OldObject, &out.OldObject, s); err != nil {
                return err
        }
        out.DryRun = (*bool)(unsafe.Pointer(in.DryRun))
        if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&in.Options, &out.Options, s); err != nil {
                return err
        }
        return nil
}

// Convert_admission_AdmissionRequest_To_v1beta1_AdmissionRequest is an autogenerated conversion function.
func Convert_admission_AdmissionRequest_To_v1beta1_AdmissionRequest(in *admission.AdmissionRequest, out *admissionv1beta1.AdmissionRequest, s conversion.Scope) error {
        return autoConvert_admission_AdmissionRequest_To_v1beta1_AdmissionRequest(in, out, s)
}

func autoConvert_v1beta1_AdmissionResponse_To_admission_AdmissionResponse(in *admissionv1beta1.AdmissionResponse, out *admission.AdmissionResponse, s conversion.Scope) error {
        out.UID = types.UID(in.UID)
        out.Allowed = in.Allowed
        out.Result = (*v1.Status)(unsafe.Pointer(in.Result))
        out.Patch = *(*[]byte)(unsafe.Pointer(&in.Patch))
        out.PatchType = (*admission.PatchType)(unsafe.Pointer(in.PatchType))
        out.AuditAnnotations = *(*map[string]string)(unsafe.Pointer(&in.AuditAnnotations))
        out.Warnings = *(*[]string)(unsafe.Pointer(&in.Warnings))
        return nil
}

// Convert_v1beta1_AdmissionResponse_To_admission_AdmissionResponse is an autogenerated conversion function.
func Convert_v1beta1_AdmissionResponse_To_admission_AdmissionResponse(in *admissionv1beta1.AdmissionResponse, out *admission.AdmissionResponse, s conversion.Scope) error {
        return autoConvert_v1beta1_AdmissionResponse_To_admission_AdmissionResponse(in, out, s)
}

func autoConvert_admission_AdmissionResponse_To_v1beta1_AdmissionResponse(in *admission.AdmissionResponse, out *admissionv1beta1.AdmissionResponse, s conversion.Scope) error {
        out.UID = types.UID(in.UID)
        out.Allowed = in.Allowed
        out.Result = (*v1.Status)(unsafe.Pointer(in.Result))
        out.Patch = *(*[]byte)(unsafe.Pointer(&in.Patch))
        out.PatchType = (*admissionv1beta1.PatchType)(unsafe.Pointer(in.PatchType))
        out.AuditAnnotations = *(*map[string]string)(unsafe.Pointer(&in.AuditAnnotations))
        out.Warnings = *(*[]string)(unsafe.Pointer(&in.Warnings))
        return nil
}

// Convert_admission_AdmissionResponse_To_v1beta1_AdmissionResponse is an autogenerated conversion function.
func Convert_admission_AdmissionResponse_To_v1beta1_AdmissionResponse(in *admission.AdmissionResponse, out *admissionv1beta1.AdmissionResponse, s conversion.Scope) error {
        return autoConvert_admission_AdmissionResponse_To_v1beta1_AdmissionResponse(in, out, s)
}

func autoConvert_v1beta1_AdmissionReview_To_admission_AdmissionReview(in *admissionv1beta1.AdmissionReview, out *admission.AdmissionReview, s conversion.Scope) error {
        if in.Request != nil {
                in, out := &in.Request, &out.Request
                *out = new(admission.AdmissionRequest)
                if err := Convert_v1beta1_AdmissionRequest_To_admission_AdmissionRequest(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Request = nil
        }
        out.Response = (*admission.AdmissionResponse)(unsafe.Pointer(in.Response))
        return nil
}

// Convert_v1beta1_AdmissionReview_To_admission_AdmissionReview is an autogenerated conversion function.
func Convert_v1beta1_AdmissionReview_To_admission_AdmissionReview(in *admissionv1beta1.AdmissionReview, out *admission.AdmissionReview, s conversion.Scope) error {
        return autoConvert_v1beta1_AdmissionReview_To_admission_AdmissionReview(in, out, s)
}

func autoConvert_admission_AdmissionReview_To_v1beta1_AdmissionReview(in *admission.AdmissionReview, out *admissionv1beta1.AdmissionReview, s conversion.Scope) error {
        if in.Request != nil {
                in, out := &in.Request, &out.Request
                *out = new(admissionv1beta1.AdmissionRequest)
                if err := Convert_admission_AdmissionRequest_To_v1beta1_AdmissionRequest(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Request = nil
        }
        out.Response = (*admissionv1beta1.AdmissionResponse)(unsafe.Pointer(in.Response))
        return nil
}

// Convert_admission_AdmissionReview_To_v1beta1_AdmissionReview is an autogenerated conversion function.
func Convert_admission_AdmissionReview_To_v1beta1_AdmissionReview(in *admission.AdmissionReview, out *admissionv1beta1.AdmissionReview, s conversion.Scope) error {
        return autoConvert_admission_AdmissionReview_To_v1beta1_AdmissionReview(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package admission

import (
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AdmissionRequest) DeepCopyInto(out *AdmissionRequest) {
        *out = *in
        out.Kind = in.Kind
        out.Resource = in.Resource
        if in.RequestKind != nil {
                in, out := &in.RequestKind, &out.RequestKind
                *out = new(v1.GroupVersionKind)
                **out = **in
        }
        if in.RequestResource != nil {
                in, out := &in.RequestResource, &out.RequestResource
                *out = new(v1.GroupVersionResource)
                **out = **in
        }
        in.UserInfo.DeepCopyInto(&out.UserInfo)
        if in.Object != nil {
                out.Object = in.Object.DeepCopyObject()
        }
        if in.OldObject != nil {
                out.OldObject = in.OldObject.DeepCopyObject()
        }
        if in.DryRun != nil {
                in, out := &in.DryRun, &out.DryRun
                *out = new(bool)
                **out = **in
        }
        if in.Options != nil {
                out.Options = in.Options.DeepCopyObject()
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AdmissionRequest.
func (in *AdmissionRequest) DeepCopy() *AdmissionRequest {
        if in == nil {
                return nil
        }
        out := new(AdmissionRequest)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AdmissionResponse) DeepCopyInto(out *AdmissionResponse) {
        *out = *in
        if in.Result != nil {
                in, out := &in.Result, &out.Result
                *out = new(v1.Status)
                (*in).DeepCopyInto(*out)
        }
        if in.Patch != nil {
                in, out := &in.Patch, &out.Patch
                *out = make([]byte, len(*in))
                copy(*out, *in)
        }
        if in.PatchType != nil {
                in, out := &in.PatchType, &out.PatchType
                *out = new(PatchType)
                **out = **in
        }
        if in.AuditAnnotations != nil {
                in, out := &in.AuditAnnotations, &out.AuditAnnotations
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.Warnings != nil {
                in, out := &in.Warnings, &out.Warnings
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AdmissionResponse.
func (in *AdmissionResponse) DeepCopy() *AdmissionResponse {
        if in == nil {
                return nil
        }
        out := new(AdmissionResponse)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AdmissionReview) DeepCopyInto(out *AdmissionReview) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        if in.Request != nil {
                in, out := &in.Request, &out.Request
                *out = new(AdmissionRequest)
                (*in).DeepCopyInto(*out)
        }
        if in.Response != nil {
                in, out := &in.Response, &out.Response
                *out = new(AdmissionResponse)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AdmissionReview.
func (in *AdmissionReview) DeepCopy() *AdmissionReview {
        if in == nil {
                return nil
        }
        out := new(AdmissionReview)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *AdmissionReview) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        "sigs.k8s.io/randfill"

        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"

        "k8s.io/kubernetes/pkg/apis/admissionregistration"
)

// Funcs returns the fuzzer functions for the admissionregistration api group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(obj *admissionregistration.Rule, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if obj.Scope == nil {
                                s := admissionregistration.AllScopes
                                obj.Scope = &s
                        }
                },
                func(obj *admissionregistration.ValidatingWebhook, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if obj.FailurePolicy == nil {
                                p := admissionregistration.FailurePolicyType("Fail")
                                obj.FailurePolicy = &p
                        }
                        if obj.MatchPolicy == nil {
                                m := admissionregistration.MatchPolicyType("Exact")
                                obj.MatchPolicy = &m
                        }
                        if obj.SideEffects == nil {
                                s := admissionregistration.SideEffectClassUnknown
                                obj.SideEffects = &s
                        }
                        if obj.TimeoutSeconds == nil {
                                i := int32(30)
                                obj.TimeoutSeconds = &i
                        }
                        obj.AdmissionReviewVersions = []string{"v1beta1"}
                },
                func(obj *admissionregistration.MutatingWebhook, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if obj.FailurePolicy == nil {
                                p := admissionregistration.FailurePolicyType("Fail")
                                obj.FailurePolicy = &p
                        }
                        if obj.MatchPolicy == nil {
                                m := admissionregistration.MatchPolicyType("Exact")
                                obj.MatchPolicy = &m
                        }
                        if obj.SideEffects == nil {
                                s := admissionregistration.SideEffectClassUnknown
                                obj.SideEffects = &s
                        }
                        if obj.ReinvocationPolicy == nil {
                                r := admissionregistration.NeverReinvocationPolicy
                                obj.ReinvocationPolicy = &r
                        }
                        if obj.TimeoutSeconds == nil {
                                i := int32(30)
                                obj.TimeoutSeconds = &i
                        }
                        obj.AdmissionReviewVersions = []string{"v1beta1"}
                },
                func(obj *admissionregistration.ValidatingAdmissionPolicySpec, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if obj.FailurePolicy == nil {
                                p := admissionregistration.FailurePolicyType("Fail")
                                obj.FailurePolicy = &p
                        }
                },
                func(obj *admissionregistration.ValidatingAdmissionPolicyBindingSpec, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if obj.ValidationActions == nil {
                                obj.ValidationActions = []admissionregistration.ValidationAction{admissionregistration.Deny}
                        }
                },
                func(obj *admissionregistration.MatchResources, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if obj.MatchPolicy == nil {
                                m := admissionregistration.MatchPolicyType("Exact")
                                obj.MatchPolicy = &m
                        }
                },
                func(obj *admissionregistration.ParamRef, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again

                        // Populate required field
                        if obj.ParameterNotFoundAction == nil {
                                v := admissionregistration.DenyAction
                                obj.ParameterNotFoundAction = &v
                        }
                },
                func(obj *admissionregistration.MutatingAdmissionPolicySpec, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if obj.FailurePolicy == nil {
                                p := admissionregistration.FailurePolicyType("Fail")
                                obj.FailurePolicy = &p
                        }
                        obj.ReinvocationPolicy = admissionregistration.NeverReinvocationPolicy
                },
                func(obj *admissionregistration.Mutation, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        patchTypes := []admissionregistration.PatchType{admissionregistration.PatchTypeJSONPatch, admissionregistration.PatchTypeApplyConfiguration}
                        obj.PatchType = patchTypes[c.Rand.Intn(len(patchTypes))]
                        if obj.PatchType == admissionregistration.PatchTypeJSONPatch {
                                obj.JSONPatch = &admissionregistration.JSONPatch{}
                                c.Fill(&obj.JSONPatch)
                                obj.ApplyConfiguration = nil
                        }
                        if obj.PatchType == admissionregistration.PatchTypeApplyConfiguration {
                                obj.ApplyConfiguration = &admissionregistration.ApplyConfiguration{}
                                c.Fill(obj.ApplyConfiguration)
                                obj.JSONPatch = nil
                        }
                },
        }
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/admissionregistration"
        v1 "k8s.io/kubernetes/pkg/apis/admissionregistration/v1"
        "k8s.io/kubernetes/pkg/apis/admissionregistration/v1alpha1"
        "k8s.io/kubernetes/pkg/apis/admissionregistration/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(admissionregistration.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1alpha1.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion, v1alpha1.SchemeGroupVersion))
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package admissionregistration

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the name used for this API group
const GroupName = "admissionregistration.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns back a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns back a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder is the scheme builder with scheme init functions to run for this API package
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme is a global function that registers this API group & version to a scheme
        AddToScheme = SchemeBuilder.AddToScheme
)

// Adds the list of known types to scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &ValidatingWebhookConfiguration{},
                &ValidatingWebhookConfigurationList{},
                &MutatingWebhookConfiguration{},
                &MutatingWebhookConfigurationList{},
                &ValidatingAdmissionPolicy{},
                &ValidatingAdmissionPolicyList{},
                &ValidatingAdmissionPolicyBinding{},
                &ValidatingAdmissionPolicyBindingList{},
                &MutatingAdmissionPolicy{},
                &MutatingAdmissionPolicyList{},
                &MutatingAdmissionPolicyBinding{},
                &MutatingAdmissionPolicyBindingList{},
        )
        return nil
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package v1

import (
        v1 "k8s.io/api/admissionregistration/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        admissionregistration "k8s.io/kubernetes/pkg/apis/admissionregistration"
)

// Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations is an autogenerated conversion function.
// This is needed because it is referenced from other APIs, but is invisible at code-generation time because of the build tags.
func Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(in *admissionregistration.RuleWithOperations, out *v1.RuleWithOperations, s conversion.Scope) error {
        return autoConvert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(in, out, s)
}

// Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations is an autogenerated conversion function.
// This is needed because it is referenced from other APIs, but is invisible at code-generation time because of the build tags.
func Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(in *v1.RuleWithOperations, out *admissionregistration.RuleWithOperations, s conversion.Scope) error {
        return autoConvert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(in, out, s)
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

package v1

import (
        admissionregistrationv1 "k8s.io/api/admissionregistration/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/utils/ptr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

// SetDefaults_ValidatingWebhook sets defaults for webhook validating
func SetDefaults_ValidatingWebhook(obj *admissionregistrationv1.ValidatingWebhook) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1.Fail
                obj.FailurePolicy = &policy
        }
        if obj.MatchPolicy == nil {
                policy := admissionregistrationv1.Equivalent
                obj.MatchPolicy = &policy
        }
        if obj.NamespaceSelector == nil {
                selector := metav1.LabelSelector{}
                obj.NamespaceSelector = &selector
        }
        if obj.ObjectSelector == nil {
                selector := metav1.LabelSelector{}
                obj.ObjectSelector = &selector
        }
        if obj.TimeoutSeconds == nil {
                obj.TimeoutSeconds = new(int32)
                *obj.TimeoutSeconds = 10
        }
}

// SetDefaults_MutatingWebhook sets defaults for webhook mutating
func SetDefaults_MutatingWebhook(obj *admissionregistrationv1.MutatingWebhook) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1.Fail
                obj.FailurePolicy = &policy
        }
        if obj.MatchPolicy == nil {
                policy := admissionregistrationv1.Equivalent
                obj.MatchPolicy = &policy
        }
        if obj.NamespaceSelector == nil {
                selector := metav1.LabelSelector{}
                obj.NamespaceSelector = &selector
        }
        if obj.ObjectSelector == nil {
                selector := metav1.LabelSelector{}
                obj.ObjectSelector = &selector
        }
        if obj.TimeoutSeconds == nil {
                obj.TimeoutSeconds = new(int32)
                *obj.TimeoutSeconds = 10
        }
        if obj.ReinvocationPolicy == nil {
                never := admissionregistrationv1.NeverReinvocationPolicy
                obj.ReinvocationPolicy = &never
        }
}

// SetDefaults_Rule sets defaults for webhook rule
func SetDefaults_Rule(obj *admissionregistrationv1.Rule) {
        if obj.Scope == nil {
                s := admissionregistrationv1.AllScopes
                obj.Scope = &s
        }
}

// SetDefaults_ServiceReference sets defaults for Webhook's ServiceReference
func SetDefaults_ServiceReference(obj *admissionregistrationv1.ServiceReference) {
        if obj.Port == nil {
                obj.Port = ptr.To[int32](443)
        }
}

// SetDefaults_ValidatingAdmissionPolicySpec sets defaults for ValidatingAdmissionPolicySpec
func SetDefaults_ValidatingAdmissionPolicySpec(obj *admissionregistrationv1.ValidatingAdmissionPolicySpec) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1.Fail
                obj.FailurePolicy = &policy
        }
}

// SetDefaults_MatchResources sets defaults for MatchResources
func SetDefaults_MatchResources(obj *admissionregistrationv1.MatchResources) {
        if obj.MatchPolicy == nil {
                policy := admissionregistrationv1.Equivalent
                obj.MatchPolicy = &policy
        }
        if obj.NamespaceSelector == nil {
                selector := metav1.LabelSelector{}
                obj.NamespaceSelector = &selector
        }
        if obj.ObjectSelector == nil {
                selector := metav1.LabelSelector{}
                obj.ObjectSelector = &selector
        }
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

package v1

import (
        admissionregistrationv1 "k8s.io/api/admissionregistration/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name used in this package
const GroupName = "admissionregistration.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &admissionregistrationv1.SchemeBuilder
        // AddToScheme handler to add items to the schema
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        admissionregistrationv1 "k8s.io/api/admissionregistration/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        admissionregistration "k8s.io/kubernetes/pkg/apis/admissionregistration"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.AuditAnnotation)(nil), (*admissionregistration.AuditAnnotation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AuditAnnotation_To_admissionregistration_AuditAnnotation(a.(*admissionregistrationv1.AuditAnnotation), b.(*admissionregistration.AuditAnnotation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.AuditAnnotation)(nil), (*admissionregistrationv1.AuditAnnotation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_AuditAnnotation_To_v1_AuditAnnotation(a.(*admissionregistration.AuditAnnotation), b.(*admissionregistrationv1.AuditAnnotation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ExpressionWarning)(nil), (*admissionregistration.ExpressionWarning)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ExpressionWarning_To_admissionregistration_ExpressionWarning(a.(*admissionregistrationv1.ExpressionWarning), b.(*admissionregistration.ExpressionWarning), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ExpressionWarning)(nil), (*admissionregistrationv1.ExpressionWarning)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ExpressionWarning_To_v1_ExpressionWarning(a.(*admissionregistration.ExpressionWarning), b.(*admissionregistrationv1.ExpressionWarning), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.MatchCondition)(nil), (*admissionregistration.MatchCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_MatchCondition_To_admissionregistration_MatchCondition(a.(*admissionregistrationv1.MatchCondition), b.(*admissionregistration.MatchCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MatchCondition)(nil), (*admissionregistrationv1.MatchCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MatchCondition_To_v1_MatchCondition(a.(*admissionregistration.MatchCondition), b.(*admissionregistrationv1.MatchCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.MatchResources)(nil), (*admissionregistration.MatchResources)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_MatchResources_To_admissionregistration_MatchResources(a.(*admissionregistrationv1.MatchResources), b.(*admissionregistration.MatchResources), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MatchResources)(nil), (*admissionregistrationv1.MatchResources)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MatchResources_To_v1_MatchResources(a.(*admissionregistration.MatchResources), b.(*admissionregistrationv1.MatchResources), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.MutatingWebhook)(nil), (*admissionregistration.MutatingWebhook)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_MutatingWebhook_To_admissionregistration_MutatingWebhook(a.(*admissionregistrationv1.MutatingWebhook), b.(*admissionregistration.MutatingWebhook), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingWebhook)(nil), (*admissionregistrationv1.MutatingWebhook)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingWebhook_To_v1_MutatingWebhook(a.(*admissionregistration.MutatingWebhook), b.(*admissionregistrationv1.MutatingWebhook), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.MutatingWebhookConfiguration)(nil), (*admissionregistration.MutatingWebhookConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(a.(*admissionregistrationv1.MutatingWebhookConfiguration), b.(*admissionregistration.MutatingWebhookConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingWebhookConfiguration)(nil), (*admissionregistrationv1.MutatingWebhookConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingWebhookConfiguration_To_v1_MutatingWebhookConfiguration(a.(*admissionregistration.MutatingWebhookConfiguration), b.(*admissionregistrationv1.MutatingWebhookConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.MutatingWebhookConfigurationList)(nil), (*admissionregistration.MutatingWebhookConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList(a.(*admissionregistrationv1.MutatingWebhookConfigurationList), b.(*admissionregistration.MutatingWebhookConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingWebhookConfigurationList)(nil), (*admissionregistrationv1.MutatingWebhookConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingWebhookConfigurationList_To_v1_MutatingWebhookConfigurationList(a.(*admissionregistration.MutatingWebhookConfigurationList), b.(*admissionregistrationv1.MutatingWebhookConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.NamedRuleWithOperations)(nil), (*admissionregistration.NamedRuleWithOperations)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(a.(*admissionregistrationv1.NamedRuleWithOperations), b.(*admissionregistration.NamedRuleWithOperations), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.NamedRuleWithOperations)(nil), (*admissionregistrationv1.NamedRuleWithOperations)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_NamedRuleWithOperations_To_v1_NamedRuleWithOperations(a.(*admissionregistration.NamedRuleWithOperations), b.(*admissionregistrationv1.NamedRuleWithOperations), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ParamKind)(nil), (*admissionregistration.ParamKind)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ParamKind_To_admissionregistration_ParamKind(a.(*admissionregistrationv1.ParamKind), b.(*admissionregistration.ParamKind), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ParamKind)(nil), (*admissionregistrationv1.ParamKind)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ParamKind_To_v1_ParamKind(a.(*admissionregistration.ParamKind), b.(*admissionregistrationv1.ParamKind), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ParamRef)(nil), (*admissionregistration.ParamRef)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ParamRef_To_admissionregistration_ParamRef(a.(*admissionregistrationv1.ParamRef), b.(*admissionregistration.ParamRef), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ParamRef)(nil), (*admissionregistrationv1.ParamRef)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ParamRef_To_v1_ParamRef(a.(*admissionregistration.ParamRef), b.(*admissionregistrationv1.ParamRef), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.Rule)(nil), (*admissionregistration.Rule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Rule_To_admissionregistration_Rule(a.(*admissionregistrationv1.Rule), b.(*admissionregistration.Rule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Rule)(nil), (*admissionregistrationv1.Rule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Rule_To_v1_Rule(a.(*admissionregistration.Rule), b.(*admissionregistrationv1.Rule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ServiceReference)(nil), (*admissionregistration.ServiceReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceReference_To_admissionregistration_ServiceReference(a.(*admissionregistrationv1.ServiceReference), b.(*admissionregistration.ServiceReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ServiceReference)(nil), (*admissionregistrationv1.ServiceReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ServiceReference_To_v1_ServiceReference(a.(*admissionregistration.ServiceReference), b.(*admissionregistrationv1.ServiceReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.TypeChecking)(nil), (*admissionregistration.TypeChecking)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TypeChecking_To_admissionregistration_TypeChecking(a.(*admissionregistrationv1.TypeChecking), b.(*admissionregistration.TypeChecking), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.TypeChecking)(nil), (*admissionregistrationv1.TypeChecking)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_TypeChecking_To_v1_TypeChecking(a.(*admissionregistration.TypeChecking), b.(*admissionregistrationv1.TypeChecking), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingAdmissionPolicy)(nil), (*admissionregistration.ValidatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(a.(*admissionregistrationv1.ValidatingAdmissionPolicy), b.(*admissionregistration.ValidatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicy)(nil), (*admissionregistrationv1.ValidatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1_ValidatingAdmissionPolicy(a.(*admissionregistration.ValidatingAdmissionPolicy), b.(*admissionregistrationv1.ValidatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingAdmissionPolicyBinding)(nil), (*admissionregistration.ValidatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(a.(*admissionregistrationv1.ValidatingAdmissionPolicyBinding), b.(*admissionregistration.ValidatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBinding)(nil), (*admissionregistrationv1.ValidatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1_ValidatingAdmissionPolicyBinding(a.(*admissionregistration.ValidatingAdmissionPolicyBinding), b.(*admissionregistrationv1.ValidatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingAdmissionPolicyBindingList)(nil), (*admissionregistration.ValidatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(a.(*admissionregistrationv1.ValidatingAdmissionPolicyBindingList), b.(*admissionregistration.ValidatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBindingList)(nil), (*admissionregistrationv1.ValidatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1_ValidatingAdmissionPolicyBindingList(a.(*admissionregistration.ValidatingAdmissionPolicyBindingList), b.(*admissionregistrationv1.ValidatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingAdmissionPolicyBindingSpec)(nil), (*admissionregistration.ValidatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(a.(*admissionregistrationv1.ValidatingAdmissionPolicyBindingSpec), b.(*admissionregistration.ValidatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBindingSpec)(nil), (*admissionregistrationv1.ValidatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1_ValidatingAdmissionPolicyBindingSpec(a.(*admissionregistration.ValidatingAdmissionPolicyBindingSpec), b.(*admissionregistrationv1.ValidatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingAdmissionPolicyList)(nil), (*admissionregistration.ValidatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(a.(*admissionregistrationv1.ValidatingAdmissionPolicyList), b.(*admissionregistration.ValidatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyList)(nil), (*admissionregistrationv1.ValidatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1_ValidatingAdmissionPolicyList(a.(*admissionregistration.ValidatingAdmissionPolicyList), b.(*admissionregistrationv1.ValidatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingAdmissionPolicySpec)(nil), (*admissionregistration.ValidatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(a.(*admissionregistrationv1.ValidatingAdmissionPolicySpec), b.(*admissionregistration.ValidatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicySpec)(nil), (*admissionregistrationv1.ValidatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1_ValidatingAdmissionPolicySpec(a.(*admissionregistration.ValidatingAdmissionPolicySpec), b.(*admissionregistrationv1.ValidatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingAdmissionPolicyStatus)(nil), (*admissionregistration.ValidatingAdmissionPolicyStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(a.(*admissionregistrationv1.ValidatingAdmissionPolicyStatus), b.(*admissionregistration.ValidatingAdmissionPolicyStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyStatus)(nil), (*admissionregistrationv1.ValidatingAdmissionPolicyStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1_ValidatingAdmissionPolicyStatus(a.(*admissionregistration.ValidatingAdmissionPolicyStatus), b.(*admissionregistrationv1.ValidatingAdmissionPolicyStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingWebhook)(nil), (*admissionregistration.ValidatingWebhook)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(a.(*admissionregistrationv1.ValidatingWebhook), b.(*admissionregistration.ValidatingWebhook), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingWebhook)(nil), (*admissionregistrationv1.ValidatingWebhook)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingWebhook_To_v1_ValidatingWebhook(a.(*admissionregistration.ValidatingWebhook), b.(*admissionregistrationv1.ValidatingWebhook), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingWebhookConfiguration)(nil), (*admissionregistration.ValidatingWebhookConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(a.(*admissionregistrationv1.ValidatingWebhookConfiguration), b.(*admissionregistration.ValidatingWebhookConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingWebhookConfiguration)(nil), (*admissionregistrationv1.ValidatingWebhookConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingWebhookConfiguration_To_v1_ValidatingWebhookConfiguration(a.(*admissionregistration.ValidatingWebhookConfiguration), b.(*admissionregistrationv1.ValidatingWebhookConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.ValidatingWebhookConfigurationList)(nil), (*admissionregistration.ValidatingWebhookConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList(a.(*admissionregistrationv1.ValidatingWebhookConfigurationList), b.(*admissionregistration.ValidatingWebhookConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingWebhookConfigurationList)(nil), (*admissionregistrationv1.ValidatingWebhookConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingWebhookConfigurationList_To_v1_ValidatingWebhookConfigurationList(a.(*admissionregistration.ValidatingWebhookConfigurationList), b.(*admissionregistrationv1.ValidatingWebhookConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.Validation)(nil), (*admissionregistration.Validation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Validation_To_admissionregistration_Validation(a.(*admissionregistrationv1.Validation), b.(*admissionregistration.Validation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Validation)(nil), (*admissionregistrationv1.Validation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Validation_To_v1_Validation(a.(*admissionregistration.Validation), b.(*admissionregistrationv1.Validation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.Variable)(nil), (*admissionregistration.Variable)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Variable_To_admissionregistration_Variable(a.(*admissionregistrationv1.Variable), b.(*admissionregistration.Variable), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Variable)(nil), (*admissionregistrationv1.Variable)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Variable_To_v1_Variable(a.(*admissionregistration.Variable), b.(*admissionregistrationv1.Variable), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1.WebhookClientConfig)(nil), (*admissionregistration.WebhookClientConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(a.(*admissionregistrationv1.WebhookClientConfig), b.(*admissionregistration.WebhookClientConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.WebhookClientConfig)(nil), (*admissionregistrationv1.WebhookClientConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_WebhookClientConfig_To_v1_WebhookClientConfig(a.(*admissionregistration.WebhookClientConfig), b.(*admissionregistrationv1.WebhookClientConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*admissionregistration.RuleWithOperations)(nil), (*admissionregistrationv1.RuleWithOperations)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(a.(*admissionregistration.RuleWithOperations), b.(*admissionregistrationv1.RuleWithOperations), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*admissionregistrationv1.RuleWithOperations)(nil), (*admissionregistration.RuleWithOperations)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(a.(*admissionregistrationv1.RuleWithOperations), b.(*admissionregistration.RuleWithOperations), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in *admissionregistrationv1.AuditAnnotation, out *admissionregistration.AuditAnnotation, s conversion.Scope) error {
        out.Key = in.Key
        out.ValueExpression = in.ValueExpression
        return nil
}

// Convert_v1_AuditAnnotation_To_admissionregistration_AuditAnnotation is an autogenerated conversion function.
func Convert_v1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in *admissionregistrationv1.AuditAnnotation, out *admissionregistration.AuditAnnotation, s conversion.Scope) error {
        return autoConvert_v1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in, out, s)
}

func autoConvert_admissionregistration_AuditAnnotation_To_v1_AuditAnnotation(in *admissionregistration.AuditAnnotation, out *admissionregistrationv1.AuditAnnotation, s conversion.Scope) error {
        out.Key = in.Key
        out.ValueExpression = in.ValueExpression
        return nil
}

// Convert_admissionregistration_AuditAnnotation_To_v1_AuditAnnotation is an autogenerated conversion function.
func Convert_admissionregistration_AuditAnnotation_To_v1_AuditAnnotation(in *admissionregistration.AuditAnnotation, out *admissionregistrationv1.AuditAnnotation, s conversion.Scope) error {
        return autoConvert_admissionregistration_AuditAnnotation_To_v1_AuditAnnotation(in, out, s)
}

func autoConvert_v1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in *admissionregistrationv1.ExpressionWarning, out *admissionregistration.ExpressionWarning, s conversion.Scope) error {
        out.FieldRef = in.FieldRef
        out.Warning = in.Warning
        return nil
}

// Convert_v1_ExpressionWarning_To_admissionregistration_ExpressionWarning is an autogenerated conversion function.
func Convert_v1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in *admissionregistrationv1.ExpressionWarning, out *admissionregistration.ExpressionWarning, s conversion.Scope) error {
        return autoConvert_v1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in, out, s)
}

func autoConvert_admissionregistration_ExpressionWarning_To_v1_ExpressionWarning(in *admissionregistration.ExpressionWarning, out *admissionregistrationv1.ExpressionWarning, s conversion.Scope) error {
        out.FieldRef = in.FieldRef
        out.Warning = in.Warning
        return nil
}

// Convert_admissionregistration_ExpressionWarning_To_v1_ExpressionWarning is an autogenerated conversion function.
func Convert_admissionregistration_ExpressionWarning_To_v1_ExpressionWarning(in *admissionregistration.ExpressionWarning, out *admissionregistrationv1.ExpressionWarning, s conversion.Scope) error {
        return autoConvert_admissionregistration_ExpressionWarning_To_v1_ExpressionWarning(in, out, s)
}

func autoConvert_v1_MatchCondition_To_admissionregistration_MatchCondition(in *admissionregistrationv1.MatchCondition, out *admissionregistration.MatchCondition, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_v1_MatchCondition_To_admissionregistration_MatchCondition is an autogenerated conversion function.
func Convert_v1_MatchCondition_To_admissionregistration_MatchCondition(in *admissionregistrationv1.MatchCondition, out *admissionregistration.MatchCondition, s conversion.Scope) error {
        return autoConvert_v1_MatchCondition_To_admissionregistration_MatchCondition(in, out, s)
}

func autoConvert_admissionregistration_MatchCondition_To_v1_MatchCondition(in *admissionregistration.MatchCondition, out *admissionregistrationv1.MatchCondition, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_MatchCondition_To_v1_MatchCondition is an autogenerated conversion function.
func Convert_admissionregistration_MatchCondition_To_v1_MatchCondition(in *admissionregistration.MatchCondition, out *admissionregistrationv1.MatchCondition, s conversion.Scope) error {
        return autoConvert_admissionregistration_MatchCondition_To_v1_MatchCondition(in, out, s)
}

func autoConvert_v1_MatchResources_To_admissionregistration_MatchResources(in *admissionregistrationv1.MatchResources, out *admissionregistration.MatchResources, s conversion.Scope) error {
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        if in.ResourceRules != nil {
                in, out := &in.ResourceRules, &out.ResourceRules
                *out = make([]admissionregistration.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_v1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ResourceRules = nil
        }
        if in.ExcludeResourceRules != nil {
                in, out := &in.ExcludeResourceRules, &out.ExcludeResourceRules
                *out = make([]admissionregistration.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_v1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ExcludeResourceRules = nil
        }
        out.MatchPolicy = (*admissionregistration.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        return nil
}

// Convert_v1_MatchResources_To_admissionregistration_MatchResources is an autogenerated conversion function.
func Convert_v1_MatchResources_To_admissionregistration_MatchResources(in *admissionregistrationv1.MatchResources, out *admissionregistration.MatchResources, s conversion.Scope) error {
        return autoConvert_v1_MatchResources_To_admissionregistration_MatchResources(in, out, s)
}

func autoConvert_admissionregistration_MatchResources_To_v1_MatchResources(in *admissionregistration.MatchResources, out *admissionregistrationv1.MatchResources, s conversion.Scope) error {
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        if in.ResourceRules != nil {
                in, out := &in.ResourceRules, &out.ResourceRules
                *out = make([]admissionregistrationv1.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_NamedRuleWithOperations_To_v1_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ResourceRules = nil
        }
        if in.ExcludeResourceRules != nil {
                in, out := &in.ExcludeResourceRules, &out.ExcludeResourceRules
                *out = make([]admissionregistrationv1.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_NamedRuleWithOperations_To_v1_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ExcludeResourceRules = nil
        }
        out.MatchPolicy = (*admissionregistrationv1.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        return nil
}

// Convert_admissionregistration_MatchResources_To_v1_MatchResources is an autogenerated conversion function.
func Convert_admissionregistration_MatchResources_To_v1_MatchResources(in *admissionregistration.MatchResources, out *admissionregistrationv1.MatchResources, s conversion.Scope) error {
        return autoConvert_admissionregistration_MatchResources_To_v1_MatchResources(in, out, s)
}

func autoConvert_v1_MutatingWebhook_To_admissionregistration_MutatingWebhook(in *admissionregistrationv1.MutatingWebhook, out *admissionregistration.MutatingWebhook, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_v1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(&in.ClientConfig, &out.ClientConfig, s); err != nil {
                return err
        }
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]admissionregistration.RuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchPolicy = (*admissionregistration.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        out.SideEffects = (*admissionregistration.SideEffectClass)(unsafe.Pointer(in.SideEffects))
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        out.AdmissionReviewVersions = *(*[]string)(unsafe.Pointer(&in.AdmissionReviewVersions))
        out.ReinvocationPolicy = (*admissionregistration.ReinvocationPolicyType)(unsafe.Pointer(in.ReinvocationPolicy))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        return nil
}

// Convert_v1_MutatingWebhook_To_admissionregistration_MutatingWebhook is an autogenerated conversion function.
func Convert_v1_MutatingWebhook_To_admissionregistration_MutatingWebhook(in *admissionregistrationv1.MutatingWebhook, out *admissionregistration.MutatingWebhook, s conversion.Scope) error {
        return autoConvert_v1_MutatingWebhook_To_admissionregistration_MutatingWebhook(in, out, s)
}

func autoConvert_admissionregistration_MutatingWebhook_To_v1_MutatingWebhook(in *admissionregistration.MutatingWebhook, out *admissionregistrationv1.MutatingWebhook, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_admissionregistration_WebhookClientConfig_To_v1_WebhookClientConfig(&in.ClientConfig, &out.ClientConfig, s); err != nil {
                return err
        }
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]admissionregistrationv1.RuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        out.FailurePolicy = (*admissionregistrationv1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchPolicy = (*admissionregistrationv1.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        out.SideEffects = (*admissionregistrationv1.SideEffectClass)(unsafe.Pointer(in.SideEffects))
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        out.AdmissionReviewVersions = *(*[]string)(unsafe.Pointer(&in.AdmissionReviewVersions))
        out.ReinvocationPolicy = (*admissionregistrationv1.ReinvocationPolicyType)(unsafe.Pointer(in.ReinvocationPolicy))
        out.MatchConditions = *(*[]admissionregistrationv1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        return nil
}

// Convert_admissionregistration_MutatingWebhook_To_v1_MutatingWebhook is an autogenerated conversion function.
func Convert_admissionregistration_MutatingWebhook_To_v1_MutatingWebhook(in *admissionregistration.MutatingWebhook, out *admissionregistrationv1.MutatingWebhook, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingWebhook_To_v1_MutatingWebhook(in, out, s)
}

func autoConvert_v1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(in *admissionregistrationv1.MutatingWebhookConfiguration, out *admissionregistration.MutatingWebhookConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]admissionregistration.MutatingWebhook, len(*in))
                for i := range *in {
                        if err := Convert_v1_MutatingWebhook_To_admissionregistration_MutatingWebhook(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Webhooks = nil
        }
        return nil
}

// Convert_v1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration is an autogenerated conversion function.
func Convert_v1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(in *admissionregistrationv1.MutatingWebhookConfiguration, out *admissionregistration.MutatingWebhookConfiguration, s conversion.Scope) error {
        return autoConvert_v1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(in, out, s)
}

func autoConvert_admissionregistration_MutatingWebhookConfiguration_To_v1_MutatingWebhookConfiguration(in *admissionregistration.MutatingWebhookConfiguration, out *admissionregistrationv1.MutatingWebhookConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]admissionregistrationv1.MutatingWebhook, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_MutatingWebhook_To_v1_MutatingWebhook(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Webhooks = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingWebhookConfiguration_To_v1_MutatingWebhookConfiguration is an autogenerated conversion function.
func Convert_admissionregistration_MutatingWebhookConfiguration_To_v1_MutatingWebhookConfiguration(in *admissionregistration.MutatingWebhookConfiguration, out *admissionregistrationv1.MutatingWebhookConfiguration, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingWebhookConfiguration_To_v1_MutatingWebhookConfiguration(in, out, s)
}

func autoConvert_v1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList(in *admissionregistrationv1.MutatingWebhookConfigurationList, out *admissionregistration.MutatingWebhookConfigurationList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.MutatingWebhookConfiguration, len(*in))
                for i := range *in {
                        if err := Convert_v1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList is an autogenerated conversion function.
func Convert_v1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList(in *admissionregistrationv1.MutatingWebhookConfigurationList, out *admissionregistration.MutatingWebhookConfigurationList, s conversion.Scope) error {
        return autoConvert_v1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList(in, out, s)
}

func autoConvert_admissionregistration_MutatingWebhookConfigurationList_To_v1_MutatingWebhookConfigurationList(in *admissionregistration.MutatingWebhookConfigurationList, out *admissionregistrationv1.MutatingWebhookConfigurationList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1.MutatingWebhookConfiguration, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_MutatingWebhookConfiguration_To_v1_MutatingWebhookConfiguration(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingWebhookConfigurationList_To_v1_MutatingWebhookConfigurationList is an autogenerated conversion function.
func Convert_admissionregistration_MutatingWebhookConfigurationList_To_v1_MutatingWebhookConfigurationList(in *admissionregistration.MutatingWebhookConfigurationList, out *admissionregistrationv1.MutatingWebhookConfigurationList, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingWebhookConfigurationList_To_v1_MutatingWebhookConfigurationList(in, out, s)
}

func autoConvert_v1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in *admissionregistrationv1.NamedRuleWithOperations, out *admissionregistration.NamedRuleWithOperations, s conversion.Scope) error {
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        if err := Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(&in.RuleWithOperations, &out.RuleWithOperations, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations is an autogenerated conversion function.
func Convert_v1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in *admissionregistrationv1.NamedRuleWithOperations, out *admissionregistration.NamedRuleWithOperations, s conversion.Scope) error {
        return autoConvert_v1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in, out, s)
}

func autoConvert_admissionregistration_NamedRuleWithOperations_To_v1_NamedRuleWithOperations(in *admissionregistration.NamedRuleWithOperations, out *admissionregistrationv1.NamedRuleWithOperations, s conversion.Scope) error {
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        if err := Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(&in.RuleWithOperations, &out.RuleWithOperations, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_NamedRuleWithOperations_To_v1_NamedRuleWithOperations is an autogenerated conversion function.
func Convert_admissionregistration_NamedRuleWithOperations_To_v1_NamedRuleWithOperations(in *admissionregistration.NamedRuleWithOperations, out *admissionregistrationv1.NamedRuleWithOperations, s conversion.Scope) error {
        return autoConvert_admissionregistration_NamedRuleWithOperations_To_v1_NamedRuleWithOperations(in, out, s)
}

func autoConvert_v1_ParamKind_To_admissionregistration_ParamKind(in *admissionregistrationv1.ParamKind, out *admissionregistration.ParamKind, s conversion.Scope) error {
        out.APIVersion = in.APIVersion
        out.Kind = in.Kind
        return nil
}

// Convert_v1_ParamKind_To_admissionregistration_ParamKind is an autogenerated conversion function.
func Convert_v1_ParamKind_To_admissionregistration_ParamKind(in *admissionregistrationv1.ParamKind, out *admissionregistration.ParamKind, s conversion.Scope) error {
        return autoConvert_v1_ParamKind_To_admissionregistration_ParamKind(in, out, s)
}

func autoConvert_admissionregistration_ParamKind_To_v1_ParamKind(in *admissionregistration.ParamKind, out *admissionregistrationv1.ParamKind, s conversion.Scope) error {
        out.APIVersion = in.APIVersion
        out.Kind = in.Kind
        return nil
}

// Convert_admissionregistration_ParamKind_To_v1_ParamKind is an autogenerated conversion function.
func Convert_admissionregistration_ParamKind_To_v1_ParamKind(in *admissionregistration.ParamKind, out *admissionregistrationv1.ParamKind, s conversion.Scope) error {
        return autoConvert_admissionregistration_ParamKind_To_v1_ParamKind(in, out, s)
}

func autoConvert_v1_ParamRef_To_admissionregistration_ParamRef(in *admissionregistrationv1.ParamRef, out *admissionregistration.ParamRef, s conversion.Scope) error {
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        out.ParameterNotFoundAction = (*admissionregistration.ParameterNotFoundActionType)(unsafe.Pointer(in.ParameterNotFoundAction))
        return nil
}

// Convert_v1_ParamRef_To_admissionregistration_ParamRef is an autogenerated conversion function.
func Convert_v1_ParamRef_To_admissionregistration_ParamRef(in *admissionregistrationv1.ParamRef, out *admissionregistration.ParamRef, s conversion.Scope) error {
        return autoConvert_v1_ParamRef_To_admissionregistration_ParamRef(in, out, s)
}

func autoConvert_admissionregistration_ParamRef_To_v1_ParamRef(in *admissionregistration.ParamRef, out *admissionregistrationv1.ParamRef, s conversion.Scope) error {
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        out.ParameterNotFoundAction = (*admissionregistrationv1.ParameterNotFoundActionType)(unsafe.Pointer(in.ParameterNotFoundAction))
        return nil
}

// Convert_admissionregistration_ParamRef_To_v1_ParamRef is an autogenerated conversion function.
func Convert_admissionregistration_ParamRef_To_v1_ParamRef(in *admissionregistration.ParamRef, out *admissionregistrationv1.ParamRef, s conversion.Scope) error {
        return autoConvert_admissionregistration_ParamRef_To_v1_ParamRef(in, out, s)
}

func autoConvert_v1_Rule_To_admissionregistration_Rule(in *admissionregistrationv1.Rule, out *admissionregistration.Rule, s conversion.Scope) error {
        out.APIGroups = *(*[]string)(unsafe.Pointer(&in.APIGroups))
        out.APIVersions = *(*[]string)(unsafe.Pointer(&in.APIVersions))
        out.Resources = *(*[]string)(unsafe.Pointer(&in.Resources))
        out.Scope = (*admissionregistration.ScopeType)(unsafe.Pointer(in.Scope))
        return nil
}

// Convert_v1_Rule_To_admissionregistration_Rule is an autogenerated conversion function.
func Convert_v1_Rule_To_admissionregistration_Rule(in *admissionregistrationv1.Rule, out *admissionregistration.Rule, s conversion.Scope) error {
        return autoConvert_v1_Rule_To_admissionregistration_Rule(in, out, s)
}

func autoConvert_admissionregistration_Rule_To_v1_Rule(in *admissionregistration.Rule, out *admissionregistrationv1.Rule, s conversion.Scope) error {
        out.APIGroups = *(*[]string)(unsafe.Pointer(&in.APIGroups))
        out.APIVersions = *(*[]string)(unsafe.Pointer(&in.APIVersions))
        out.Resources = *(*[]string)(unsafe.Pointer(&in.Resources))
        out.Scope = (*admissionregistrationv1.ScopeType)(unsafe.Pointer(in.Scope))
        return nil
}

// Convert_admissionregistration_Rule_To_v1_Rule is an autogenerated conversion function.
func Convert_admissionregistration_Rule_To_v1_Rule(in *admissionregistration.Rule, out *admissionregistrationv1.Rule, s conversion.Scope) error {
        return autoConvert_admissionregistration_Rule_To_v1_Rule(in, out, s)
}

func autoConvert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(in *admissionregistrationv1.RuleWithOperations, out *admissionregistration.RuleWithOperations, s conversion.Scope) error {
        out.Operations = *(*[]admissionregistration.OperationType)(unsafe.Pointer(&in.Operations))
        if err := Convert_v1_Rule_To_admissionregistration_Rule(&in.Rule, &out.Rule, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(in *admissionregistration.RuleWithOperations, out *admissionregistrationv1.RuleWithOperations, s conversion.Scope) error {
        out.Operations = *(*[]admissionregistrationv1.OperationType)(unsafe.Pointer(&in.Operations))
        if err := Convert_admissionregistration_Rule_To_v1_Rule(&in.Rule, &out.Rule, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_ServiceReference_To_admissionregistration_ServiceReference(in *admissionregistrationv1.ServiceReference, out *admissionregistration.ServiceReference, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Name = in.Name
        out.Path = (*string)(unsafe.Pointer(in.Path))
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Port, &out.Port, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_ServiceReference_To_admissionregistration_ServiceReference is an autogenerated conversion function.
func Convert_v1_ServiceReference_To_admissionregistration_ServiceReference(in *admissionregistrationv1.ServiceReference, out *admissionregistration.ServiceReference, s conversion.Scope) error {
        return autoConvert_v1_ServiceReference_To_admissionregistration_ServiceReference(in, out, s)
}

func autoConvert_admissionregistration_ServiceReference_To_v1_ServiceReference(in *admissionregistration.ServiceReference, out *admissionregistrationv1.ServiceReference, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Name = in.Name
        out.Path = (*string)(unsafe.Pointer(in.Path))
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Port, &out.Port, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_ServiceReference_To_v1_ServiceReference is an autogenerated conversion function.
func Convert_admissionregistration_ServiceReference_To_v1_ServiceReference(in *admissionregistration.ServiceReference, out *admissionregistrationv1.ServiceReference, s conversion.Scope) error {
        return autoConvert_admissionregistration_ServiceReference_To_v1_ServiceReference(in, out, s)
}

func autoConvert_v1_TypeChecking_To_admissionregistration_TypeChecking(in *admissionregistrationv1.TypeChecking, out *admissionregistration.TypeChecking, s conversion.Scope) error {
        out.ExpressionWarnings = *(*[]admissionregistration.ExpressionWarning)(unsafe.Pointer(&in.ExpressionWarnings))
        return nil
}

// Convert_v1_TypeChecking_To_admissionregistration_TypeChecking is an autogenerated conversion function.
func Convert_v1_TypeChecking_To_admissionregistration_TypeChecking(in *admissionregistrationv1.TypeChecking, out *admissionregistration.TypeChecking, s conversion.Scope) error {
        return autoConvert_v1_TypeChecking_To_admissionregistration_TypeChecking(in, out, s)
}

func autoConvert_admissionregistration_TypeChecking_To_v1_TypeChecking(in *admissionregistration.TypeChecking, out *admissionregistrationv1.TypeChecking, s conversion.Scope) error {
        out.ExpressionWarnings = *(*[]admissionregistrationv1.ExpressionWarning)(unsafe.Pointer(&in.ExpressionWarnings))
        return nil
}

// Convert_admissionregistration_TypeChecking_To_v1_TypeChecking is an autogenerated conversion function.
func Convert_admissionregistration_TypeChecking_To_v1_TypeChecking(in *admissionregistration.TypeChecking, out *admissionregistrationv1.TypeChecking, s conversion.Scope) error {
        return autoConvert_admissionregistration_TypeChecking_To_v1_TypeChecking(in, out, s)
}

func autoConvert_v1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in *admissionregistrationv1.ValidatingAdmissionPolicy, out *admissionregistration.ValidatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy is an autogenerated conversion function.
func Convert_v1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in *admissionregistrationv1.ValidatingAdmissionPolicy, out *admissionregistration.ValidatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_v1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicy_To_v1_ValidatingAdmissionPolicy(in *admissionregistration.ValidatingAdmissionPolicy, out *admissionregistrationv1.ValidatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1_ValidatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1_ValidatingAdmissionPolicyStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1_ValidatingAdmissionPolicy is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1_ValidatingAdmissionPolicy(in *admissionregistration.ValidatingAdmissionPolicy, out *admissionregistrationv1.ValidatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicy_To_v1_ValidatingAdmissionPolicy(in, out, s)
}

func autoConvert_v1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1.ValidatingAdmissionPolicyBinding, out *admissionregistration.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_v1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1.ValidatingAdmissionPolicyBinding, out *admissionregistration.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_v1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1_ValidatingAdmissionPolicyBinding(in *admissionregistration.ValidatingAdmissionPolicyBinding, out *admissionregistrationv1.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1_ValidatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1_ValidatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1_ValidatingAdmissionPolicyBinding(in *admissionregistration.ValidatingAdmissionPolicyBinding, out *admissionregistrationv1.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1_ValidatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_v1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1.ValidatingAdmissionPolicyBindingList, out *admissionregistration.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.ValidatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_v1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_v1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1.ValidatingAdmissionPolicyBindingList, out *admissionregistration.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_v1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1_ValidatingAdmissionPolicyBindingList(in *admissionregistration.ValidatingAdmissionPolicyBindingList, out *admissionregistrationv1.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1.ValidatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1_ValidatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1_ValidatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1_ValidatingAdmissionPolicyBindingList(in *admissionregistration.ValidatingAdmissionPolicyBindingList, out *admissionregistrationv1.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1_ValidatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_v1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in *admissionregistrationv1.ValidatingAdmissionPolicyBindingSpec, out *admissionregistration.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistration.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        out.ValidationActions = *(*[]admissionregistration.ValidationAction)(unsafe.Pointer(&in.ValidationActions))
        return nil
}

// Convert_v1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_v1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in *admissionregistrationv1.ValidatingAdmissionPolicyBindingSpec, out *admissionregistration.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_v1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1_ValidatingAdmissionPolicyBindingSpec(in *admissionregistration.ValidatingAdmissionPolicyBindingSpec, out *admissionregistrationv1.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistrationv1.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistrationv1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        out.ValidationActions = *(*[]admissionregistrationv1.ValidationAction)(unsafe.Pointer(&in.ValidationActions))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1_ValidatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1_ValidatingAdmissionPolicyBindingSpec(in *admissionregistration.ValidatingAdmissionPolicyBindingSpec, out *admissionregistrationv1.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1_ValidatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_v1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in *admissionregistrationv1.ValidatingAdmissionPolicyList, out *admissionregistration.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.ValidatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_v1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_v1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in *admissionregistrationv1.ValidatingAdmissionPolicyList, out *admissionregistration.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_v1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyList_To_v1_ValidatingAdmissionPolicyList(in *admissionregistration.ValidatingAdmissionPolicyList, out *admissionregistrationv1.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1.ValidatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1_ValidatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1_ValidatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1_ValidatingAdmissionPolicyList(in *admissionregistration.ValidatingAdmissionPolicyList, out *admissionregistrationv1.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyList_To_v1_ValidatingAdmissionPolicyList(in, out, s)
}

func autoConvert_v1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in *admissionregistrationv1.ValidatingAdmissionPolicySpec, out *admissionregistration.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistration.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Validations = *(*[]admissionregistration.Validation)(unsafe.Pointer(&in.Validations))
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.AuditAnnotations = *(*[]admissionregistration.AuditAnnotation)(unsafe.Pointer(&in.AuditAnnotations))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.Variables = *(*[]admissionregistration.Variable)(unsafe.Pointer(&in.Variables))
        return nil
}

// Convert_v1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_v1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in *admissionregistrationv1.ValidatingAdmissionPolicySpec, out *admissionregistration.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_v1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1_ValidatingAdmissionPolicySpec(in *admissionregistration.ValidatingAdmissionPolicySpec, out *admissionregistrationv1.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistrationv1.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistrationv1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Validations = *(*[]admissionregistrationv1.Validation)(unsafe.Pointer(&in.Validations))
        out.MatchConditions = *(*[]admissionregistrationv1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.FailurePolicy = (*admissionregistrationv1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.AuditAnnotations = *(*[]admissionregistrationv1.AuditAnnotation)(unsafe.Pointer(&in.AuditAnnotations))
        out.Variables = *(*[]admissionregistrationv1.Variable)(unsafe.Pointer(&in.Variables))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1_ValidatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1_ValidatingAdmissionPolicySpec(in *admissionregistration.ValidatingAdmissionPolicySpec, out *admissionregistrationv1.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1_ValidatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_v1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in *admissionregistrationv1.ValidatingAdmissionPolicyStatus, out *admissionregistration.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.TypeChecking = (*admissionregistration.TypeChecking)(unsafe.Pointer(in.TypeChecking))
        out.Conditions = *(*[]metav1.Condition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus is an autogenerated conversion function.
func Convert_v1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in *admissionregistrationv1.ValidatingAdmissionPolicyStatus, out *admissionregistration.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        return autoConvert_v1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1_ValidatingAdmissionPolicyStatus(in *admissionregistration.ValidatingAdmissionPolicyStatus, out *admissionregistrationv1.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.TypeChecking = (*admissionregistrationv1.TypeChecking)(unsafe.Pointer(in.TypeChecking))
        out.Conditions = *(*[]metav1.Condition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1_ValidatingAdmissionPolicyStatus is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1_ValidatingAdmissionPolicyStatus(in *admissionregistration.ValidatingAdmissionPolicyStatus, out *admissionregistrationv1.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1_ValidatingAdmissionPolicyStatus(in, out, s)
}

func autoConvert_v1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(in *admissionregistrationv1.ValidatingWebhook, out *admissionregistration.ValidatingWebhook, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_v1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(&in.ClientConfig, &out.ClientConfig, s); err != nil {
                return err
        }
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]admissionregistration.RuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchPolicy = (*admissionregistration.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        out.SideEffects = (*admissionregistration.SideEffectClass)(unsafe.Pointer(in.SideEffects))
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        out.AdmissionReviewVersions = *(*[]string)(unsafe.Pointer(&in.AdmissionReviewVersions))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        return nil
}

// Convert_v1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook is an autogenerated conversion function.
func Convert_v1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(in *admissionregistrationv1.ValidatingWebhook, out *admissionregistration.ValidatingWebhook, s conversion.Scope) error {
        return autoConvert_v1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(in, out, s)
}

func autoConvert_admissionregistration_ValidatingWebhook_To_v1_ValidatingWebhook(in *admissionregistration.ValidatingWebhook, out *admissionregistrationv1.ValidatingWebhook, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_admissionregistration_WebhookClientConfig_To_v1_WebhookClientConfig(&in.ClientConfig, &out.ClientConfig, s); err != nil {
                return err
        }
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]admissionregistrationv1.RuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        out.FailurePolicy = (*admissionregistrationv1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchPolicy = (*admissionregistrationv1.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        out.SideEffects = (*admissionregistrationv1.SideEffectClass)(unsafe.Pointer(in.SideEffects))
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        out.AdmissionReviewVersions = *(*[]string)(unsafe.Pointer(&in.AdmissionReviewVersions))
        out.MatchConditions = *(*[]admissionregistrationv1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        return nil
}

// Convert_admissionregistration_ValidatingWebhook_To_v1_ValidatingWebhook is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingWebhook_To_v1_ValidatingWebhook(in *admissionregistration.ValidatingWebhook, out *admissionregistrationv1.ValidatingWebhook, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingWebhook_To_v1_ValidatingWebhook(in, out, s)
}

func autoConvert_v1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(in *admissionregistrationv1.ValidatingWebhookConfiguration, out *admissionregistration.ValidatingWebhookConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]admissionregistration.ValidatingWebhook, len(*in))
                for i := range *in {
                        if err := Convert_v1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Webhooks = nil
        }
        return nil
}

// Convert_v1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration is an autogenerated conversion function.
func Convert_v1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(in *admissionregistrationv1.ValidatingWebhookConfiguration, out *admissionregistration.ValidatingWebhookConfiguration, s conversion.Scope) error {
        return autoConvert_v1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(in, out, s)
}

func autoConvert_admissionregistration_ValidatingWebhookConfiguration_To_v1_ValidatingWebhookConfiguration(in *admissionregistration.ValidatingWebhookConfiguration, out *admissionregistrationv1.ValidatingWebhookConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]admissionregistrationv1.ValidatingWebhook, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingWebhook_To_v1_ValidatingWebhook(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Webhooks = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingWebhookConfiguration_To_v1_ValidatingWebhookConfiguration is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingWebhookConfiguration_To_v1_ValidatingWebhookConfiguration(in *admissionregistration.ValidatingWebhookConfiguration, out *admissionregistrationv1.ValidatingWebhookConfiguration, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingWebhookConfiguration_To_v1_ValidatingWebhookConfiguration(in, out, s)
}

func autoConvert_v1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList(in *admissionregistrationv1.ValidatingWebhookConfigurationList, out *admissionregistration.ValidatingWebhookConfigurationList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.ValidatingWebhookConfiguration, len(*in))
                for i := range *in {
                        if err := Convert_v1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList is an autogenerated conversion function.
func Convert_v1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList(in *admissionregistrationv1.ValidatingWebhookConfigurationList, out *admissionregistration.ValidatingWebhookConfigurationList, s conversion.Scope) error {
        return autoConvert_v1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList(in, out, s)
}

func autoConvert_admissionregistration_ValidatingWebhookConfigurationList_To_v1_ValidatingWebhookConfigurationList(in *admissionregistration.ValidatingWebhookConfigurationList, out *admissionregistrationv1.ValidatingWebhookConfigurationList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1.ValidatingWebhookConfiguration, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingWebhookConfiguration_To_v1_ValidatingWebhookConfiguration(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingWebhookConfigurationList_To_v1_ValidatingWebhookConfigurationList is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingWebhookConfigurationList_To_v1_ValidatingWebhookConfigurationList(in *admissionregistration.ValidatingWebhookConfigurationList, out *admissionregistrationv1.ValidatingWebhookConfigurationList, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingWebhookConfigurationList_To_v1_ValidatingWebhookConfigurationList(in, out, s)
}

func autoConvert_v1_Validation_To_admissionregistration_Validation(in *admissionregistrationv1.Validation, out *admissionregistration.Validation, s conversion.Scope) error {
        out.Expression = in.Expression
        out.Message = in.Message
        out.Reason = (*metav1.StatusReason)(unsafe.Pointer(in.Reason))
        out.MessageExpression = in.MessageExpression
        return nil
}

// Convert_v1_Validation_To_admissionregistration_Validation is an autogenerated conversion function.
func Convert_v1_Validation_To_admissionregistration_Validation(in *admissionregistrationv1.Validation, out *admissionregistration.Validation, s conversion.Scope) error {
        return autoConvert_v1_Validation_To_admissionregistration_Validation(in, out, s)
}

func autoConvert_admissionregistration_Validation_To_v1_Validation(in *admissionregistration.Validation, out *admissionregistrationv1.Validation, s conversion.Scope) error {
        out.Expression = in.Expression
        out.Message = in.Message
        out.Reason = (*metav1.StatusReason)(unsafe.Pointer(in.Reason))
        out.MessageExpression = in.MessageExpression
        return nil
}

// Convert_admissionregistration_Validation_To_v1_Validation is an autogenerated conversion function.
func Convert_admissionregistration_Validation_To_v1_Validation(in *admissionregistration.Validation, out *admissionregistrationv1.Validation, s conversion.Scope) error {
        return autoConvert_admissionregistration_Validation_To_v1_Validation(in, out, s)
}

func autoConvert_v1_Variable_To_admissionregistration_Variable(in *admissionregistrationv1.Variable, out *admissionregistration.Variable, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_v1_Variable_To_admissionregistration_Variable is an autogenerated conversion function.
func Convert_v1_Variable_To_admissionregistration_Variable(in *admissionregistrationv1.Variable, out *admissionregistration.Variable, s conversion.Scope) error {
        return autoConvert_v1_Variable_To_admissionregistration_Variable(in, out, s)
}

func autoConvert_admissionregistration_Variable_To_v1_Variable(in *admissionregistration.Variable, out *admissionregistrationv1.Variable, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_Variable_To_v1_Variable is an autogenerated conversion function.
func Convert_admissionregistration_Variable_To_v1_Variable(in *admissionregistration.Variable, out *admissionregistrationv1.Variable, s conversion.Scope) error {
        return autoConvert_admissionregistration_Variable_To_v1_Variable(in, out, s)
}

func autoConvert_v1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(in *admissionregistrationv1.WebhookClientConfig, out *admissionregistration.WebhookClientConfig, s conversion.Scope) error {
        out.URL = (*string)(unsafe.Pointer(in.URL))
        if in.Service != nil {
                in, out := &in.Service, &out.Service
                *out = new(admissionregistration.ServiceReference)
                if err := Convert_v1_ServiceReference_To_admissionregistration_ServiceReference(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Service = nil
        }
        out.CABundle = *(*[]byte)(unsafe.Pointer(&in.CABundle))
        return nil
}

// Convert_v1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig is an autogenerated conversion function.
func Convert_v1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(in *admissionregistrationv1.WebhookClientConfig, out *admissionregistration.WebhookClientConfig, s conversion.Scope) error {
        return autoConvert_v1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(in, out, s)
}

func autoConvert_admissionregistration_WebhookClientConfig_To_v1_WebhookClientConfig(in *admissionregistration.WebhookClientConfig, out *admissionregistrationv1.WebhookClientConfig, s conversion.Scope) error {
        out.URL = (*string)(unsafe.Pointer(in.URL))
        if in.Service != nil {
                in, out := &in.Service, &out.Service
                *out = new(admissionregistrationv1.ServiceReference)
                if err := Convert_admissionregistration_ServiceReference_To_v1_ServiceReference(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Service = nil
        }
        out.CABundle = *(*[]byte)(unsafe.Pointer(&in.CABundle))
        return nil
}

// Convert_admissionregistration_WebhookClientConfig_To_v1_WebhookClientConfig is an autogenerated conversion function.
func Convert_admissionregistration_WebhookClientConfig_To_v1_WebhookClientConfig(in *admissionregistration.WebhookClientConfig, out *admissionregistrationv1.WebhookClientConfig, s conversion.Scope) error {
        return autoConvert_admissionregistration_WebhookClientConfig_To_v1_WebhookClientConfig(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        admissionregistrationv1 "k8s.io/api/admissionregistration/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1.MutatingWebhookConfiguration{}, func(obj interface{}) {
                SetObjectDefaults_MutatingWebhookConfiguration(obj.(*admissionregistrationv1.MutatingWebhookConfiguration))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1.MutatingWebhookConfigurationList{}, func(obj interface{}) {
                SetObjectDefaults_MutatingWebhookConfigurationList(obj.(*admissionregistrationv1.MutatingWebhookConfigurationList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1.ValidatingAdmissionPolicy{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicy(obj.(*admissionregistrationv1.ValidatingAdmissionPolicy))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1.ValidatingAdmissionPolicyBinding{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyBinding(obj.(*admissionregistrationv1.ValidatingAdmissionPolicyBinding))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1.ValidatingAdmissionPolicyBindingList{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyBindingList(obj.(*admissionregistrationv1.ValidatingAdmissionPolicyBindingList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1.ValidatingAdmissionPolicyList{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyList(obj.(*admissionregistrationv1.ValidatingAdmissionPolicyList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1.ValidatingWebhookConfiguration{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingWebhookConfiguration(obj.(*admissionregistrationv1.ValidatingWebhookConfiguration))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1.ValidatingWebhookConfigurationList{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingWebhookConfigurationList(obj.(*admissionregistrationv1.ValidatingWebhookConfigurationList))
        })
        return nil
}

func SetObjectDefaults_MutatingWebhookConfiguration(in *admissionregistrationv1.MutatingWebhookConfiguration) {
        for i := range in.Webhooks {
                a := &in.Webhooks[i]
                SetDefaults_MutatingWebhook(a)
                if a.ClientConfig.Service != nil {
                        SetDefaults_ServiceReference(a.ClientConfig.Service)
                }
                for j := range a.Rules {
                        b := &a.Rules[j]
                        SetDefaults_Rule(&b.Rule)
                }
        }
}

func SetObjectDefaults_MutatingWebhookConfigurationList(in *admissionregistrationv1.MutatingWebhookConfigurationList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_MutatingWebhookConfiguration(a)
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicy(in *admissionregistrationv1.ValidatingAdmissionPolicy) {
        SetDefaults_ValidatingAdmissionPolicySpec(&in.Spec)
        if in.Spec.MatchConstraints != nil {
                SetDefaults_MatchResources(in.Spec.MatchConstraints)
                for i := range in.Spec.MatchConstraints.ResourceRules {
                        a := &in.Spec.MatchConstraints.ResourceRules[i]
                        SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchConstraints.ExcludeResourceRules {
                        a := &in.Spec.MatchConstraints.ExcludeResourceRules[i]
                        SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1.ValidatingAdmissionPolicyBinding) {
        if in.Spec.MatchResources != nil {
                SetDefaults_MatchResources(in.Spec.MatchResources)
                for i := range in.Spec.MatchResources.ResourceRules {
                        a := &in.Spec.MatchResources.ResourceRules[i]
                        SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchResources.ExcludeResourceRules {
                        a := &in.Spec.MatchResources.ExcludeResourceRules[i]
                        SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1.ValidatingAdmissionPolicyBindingList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ValidatingAdmissionPolicyBinding(a)
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyList(in *admissionregistrationv1.ValidatingAdmissionPolicyList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ValidatingAdmissionPolicy(a)
        }
}

func SetObjectDefaults_ValidatingWebhookConfiguration(in *admissionregistrationv1.ValidatingWebhookConfiguration) {
        for i := range in.Webhooks {
                a := &in.Webhooks[i]
                SetDefaults_ValidatingWebhook(a)
                if a.ClientConfig.Service != nil {
                        SetDefaults_ServiceReference(a.ClientConfig.Service)
                }
                for j := range a.Rules {
                        b := &a.Rules[j]
                        SetDefaults_Rule(&b.Rule)
                }
        }
}

func SetObjectDefaults_ValidatingWebhookConfigurationList(in *admissionregistrationv1.ValidatingWebhookConfigurationList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ValidatingWebhookConfiguration(a)
        }
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package v1alpha1

import (
        admissionregistrationv1alpha1 "k8s.io/api/admissionregistration/v1alpha1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

// SetDefaults_ValidatingAdmissionPolicySpec sets defaults for ValidatingAdmissionPolicySpec
func SetDefaults_ValidatingAdmissionPolicySpec(obj *admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1alpha1.Fail
                obj.FailurePolicy = &policy
        }
}

// SetDefaults_MatchResources sets defaults for MatchResources
func SetDefaults_MatchResources(obj *admissionregistrationv1alpha1.MatchResources) {
        if obj.MatchPolicy == nil {
                policy := admissionregistrationv1alpha1.Equivalent
                obj.MatchPolicy = &policy
        }
        if obj.NamespaceSelector == nil {
                selector := metav1.LabelSelector{}
                obj.NamespaceSelector = &selector
        }
        if obj.ObjectSelector == nil {
                selector := metav1.LabelSelector{}
                obj.ObjectSelector = &selector
        }
}

// SetDefaults_ParamRef sets defaults for ParamRef
func SetDefaults_ParamRef(obj *admissionregistrationv1alpha1.ParamRef) {
        if obj.ParameterNotFoundAction == nil {
                v := admissionregistrationv1alpha1.DenyAction
                obj.ParameterNotFoundAction = &v
        }
}

// SetDefaults_MutatingAdmissionPolicySpec sets defaults for MutatingAdmissionPolicySpec
func SetDefaults_MutatingAdmissionPolicySpec(obj *admissionregistrationv1alpha1.MutatingAdmissionPolicySpec) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1alpha1.Fail
                obj.FailurePolicy = &policy
        }
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package v1alpha1

import (
        admissionregistrationv1alpha1 "k8s.io/api/admissionregistration/v1alpha1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name used in this package
const GroupName = "admissionregistration.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &admissionregistrationv1alpha1.SchemeBuilder
        // AddToScheme handler to add items to the schema
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1alpha1

import (
        unsafe "unsafe"

        admissionregistrationv1 "k8s.io/api/admissionregistration/v1"
        admissionregistrationv1alpha1 "k8s.io/api/admissionregistration/v1alpha1"
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        admissionregistration "k8s.io/kubernetes/pkg/apis/admissionregistration"
        apisadmissionregistrationv1 "k8s.io/kubernetes/pkg/apis/admissionregistration/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ApplyConfiguration)(nil), (*admissionregistration.ApplyConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration(a.(*admissionregistrationv1alpha1.ApplyConfiguration), b.(*admissionregistration.ApplyConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ApplyConfiguration)(nil), (*admissionregistrationv1alpha1.ApplyConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ApplyConfiguration_To_v1alpha1_ApplyConfiguration(a.(*admissionregistration.ApplyConfiguration), b.(*admissionregistrationv1alpha1.ApplyConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.AuditAnnotation)(nil), (*admissionregistration.AuditAnnotation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_AuditAnnotation_To_admissionregistration_AuditAnnotation(a.(*admissionregistrationv1alpha1.AuditAnnotation), b.(*admissionregistration.AuditAnnotation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.AuditAnnotation)(nil), (*admissionregistrationv1alpha1.AuditAnnotation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_AuditAnnotation_To_v1alpha1_AuditAnnotation(a.(*admissionregistration.AuditAnnotation), b.(*admissionregistrationv1alpha1.AuditAnnotation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ExpressionWarning)(nil), (*admissionregistration.ExpressionWarning)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ExpressionWarning_To_admissionregistration_ExpressionWarning(a.(*admissionregistrationv1alpha1.ExpressionWarning), b.(*admissionregistration.ExpressionWarning), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ExpressionWarning)(nil), (*admissionregistrationv1alpha1.ExpressionWarning)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ExpressionWarning_To_v1alpha1_ExpressionWarning(a.(*admissionregistration.ExpressionWarning), b.(*admissionregistrationv1alpha1.ExpressionWarning), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.JSONPatch)(nil), (*admissionregistration.JSONPatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_JSONPatch_To_admissionregistration_JSONPatch(a.(*admissionregistrationv1alpha1.JSONPatch), b.(*admissionregistration.JSONPatch), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.JSONPatch)(nil), (*admissionregistrationv1alpha1.JSONPatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_JSONPatch_To_v1alpha1_JSONPatch(a.(*admissionregistration.JSONPatch), b.(*admissionregistrationv1alpha1.JSONPatch), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.MatchCondition)(nil), (*admissionregistration.MatchCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_MatchCondition_To_admissionregistration_MatchCondition(a.(*admissionregistrationv1alpha1.MatchCondition), b.(*admissionregistration.MatchCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MatchCondition)(nil), (*admissionregistrationv1alpha1.MatchCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MatchCondition_To_v1alpha1_MatchCondition(a.(*admissionregistration.MatchCondition), b.(*admissionregistrationv1alpha1.MatchCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.MatchResources)(nil), (*admissionregistration.MatchResources)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_MatchResources_To_admissionregistration_MatchResources(a.(*admissionregistrationv1alpha1.MatchResources), b.(*admissionregistration.MatchResources), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MatchResources)(nil), (*admissionregistrationv1alpha1.MatchResources)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MatchResources_To_v1alpha1_MatchResources(a.(*admissionregistration.MatchResources), b.(*admissionregistrationv1alpha1.MatchResources), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.MutatingAdmissionPolicy)(nil), (*admissionregistration.MutatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(a.(*admissionregistrationv1alpha1.MutatingAdmissionPolicy), b.(*admissionregistration.MutatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicy)(nil), (*admissionregistrationv1alpha1.MutatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicy_To_v1alpha1_MutatingAdmissionPolicy(a.(*admissionregistration.MutatingAdmissionPolicy), b.(*admissionregistrationv1alpha1.MutatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding)(nil), (*admissionregistration.MutatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(a.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding), b.(*admissionregistration.MutatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicyBinding)(nil), (*admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1alpha1_MutatingAdmissionPolicyBinding(a.(*admissionregistration.MutatingAdmissionPolicyBinding), b.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList)(nil), (*admissionregistration.MutatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList(a.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList), b.(*admissionregistration.MutatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicyBindingList)(nil), (*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1alpha1_MutatingAdmissionPolicyBindingList(a.(*admissionregistration.MutatingAdmissionPolicyBindingList), b.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingSpec)(nil), (*admissionregistration.MutatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(a.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingSpec), b.(*admissionregistration.MutatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicyBindingSpec)(nil), (*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1alpha1_MutatingAdmissionPolicyBindingSpec(a.(*admissionregistration.MutatingAdmissionPolicyBindingSpec), b.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.MutatingAdmissionPolicyList)(nil), (*admissionregistration.MutatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList(a.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyList), b.(*admissionregistration.MutatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicyList)(nil), (*admissionregistrationv1alpha1.MutatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicyList_To_v1alpha1_MutatingAdmissionPolicyList(a.(*admissionregistration.MutatingAdmissionPolicyList), b.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.MutatingAdmissionPolicySpec)(nil), (*admissionregistration.MutatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(a.(*admissionregistrationv1alpha1.MutatingAdmissionPolicySpec), b.(*admissionregistration.MutatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicySpec)(nil), (*admissionregistrationv1alpha1.MutatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicySpec_To_v1alpha1_MutatingAdmissionPolicySpec(a.(*admissionregistration.MutatingAdmissionPolicySpec), b.(*admissionregistrationv1alpha1.MutatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.Mutation)(nil), (*admissionregistration.Mutation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_Mutation_To_admissionregistration_Mutation(a.(*admissionregistrationv1alpha1.Mutation), b.(*admissionregistration.Mutation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Mutation)(nil), (*admissionregistrationv1alpha1.Mutation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Mutation_To_v1alpha1_Mutation(a.(*admissionregistration.Mutation), b.(*admissionregistrationv1alpha1.Mutation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.NamedRuleWithOperations)(nil), (*admissionregistration.NamedRuleWithOperations)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(a.(*admissionregistrationv1alpha1.NamedRuleWithOperations), b.(*admissionregistration.NamedRuleWithOperations), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.NamedRuleWithOperations)(nil), (*admissionregistrationv1alpha1.NamedRuleWithOperations)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_NamedRuleWithOperations_To_v1alpha1_NamedRuleWithOperations(a.(*admissionregistration.NamedRuleWithOperations), b.(*admissionregistrationv1alpha1.NamedRuleWithOperations), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ParamKind)(nil), (*admissionregistration.ParamKind)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ParamKind_To_admissionregistration_ParamKind(a.(*admissionregistrationv1alpha1.ParamKind), b.(*admissionregistration.ParamKind), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ParamKind)(nil), (*admissionregistrationv1alpha1.ParamKind)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ParamKind_To_v1alpha1_ParamKind(a.(*admissionregistration.ParamKind), b.(*admissionregistrationv1alpha1.ParamKind), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ParamRef)(nil), (*admissionregistration.ParamRef)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ParamRef_To_admissionregistration_ParamRef(a.(*admissionregistrationv1alpha1.ParamRef), b.(*admissionregistration.ParamRef), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ParamRef)(nil), (*admissionregistrationv1alpha1.ParamRef)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ParamRef_To_v1alpha1_ParamRef(a.(*admissionregistration.ParamRef), b.(*admissionregistrationv1alpha1.ParamRef), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.TypeChecking)(nil), (*admissionregistration.TypeChecking)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_TypeChecking_To_admissionregistration_TypeChecking(a.(*admissionregistrationv1alpha1.TypeChecking), b.(*admissionregistration.TypeChecking), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.TypeChecking)(nil), (*admissionregistrationv1alpha1.TypeChecking)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_TypeChecking_To_v1alpha1_TypeChecking(a.(*admissionregistration.TypeChecking), b.(*admissionregistrationv1alpha1.TypeChecking), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ValidatingAdmissionPolicy)(nil), (*admissionregistration.ValidatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(a.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicy), b.(*admissionregistration.ValidatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicy)(nil), (*admissionregistrationv1alpha1.ValidatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1alpha1_ValidatingAdmissionPolicy(a.(*admissionregistration.ValidatingAdmissionPolicy), b.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding)(nil), (*admissionregistration.ValidatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(a.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding), b.(*admissionregistration.ValidatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBinding)(nil), (*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1alpha1_ValidatingAdmissionPolicyBinding(a.(*admissionregistration.ValidatingAdmissionPolicyBinding), b.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList)(nil), (*admissionregistration.ValidatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(a.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList), b.(*admissionregistration.ValidatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBindingList)(nil), (*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1alpha1_ValidatingAdmissionPolicyBindingList(a.(*admissionregistration.ValidatingAdmissionPolicyBindingList), b.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingSpec)(nil), (*admissionregistration.ValidatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(a.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingSpec), b.(*admissionregistration.ValidatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBindingSpec)(nil), (*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1alpha1_ValidatingAdmissionPolicyBindingSpec(a.(*admissionregistration.ValidatingAdmissionPolicyBindingSpec), b.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ValidatingAdmissionPolicyList)(nil), (*admissionregistration.ValidatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(a.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyList), b.(*admissionregistration.ValidatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyList)(nil), (*admissionregistrationv1alpha1.ValidatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1alpha1_ValidatingAdmissionPolicyList(a.(*admissionregistration.ValidatingAdmissionPolicyList), b.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec)(nil), (*admissionregistration.ValidatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(a.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec), b.(*admissionregistration.ValidatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicySpec)(nil), (*admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1alpha1_ValidatingAdmissionPolicySpec(a.(*admissionregistration.ValidatingAdmissionPolicySpec), b.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.ValidatingAdmissionPolicyStatus)(nil), (*admissionregistration.ValidatingAdmissionPolicyStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(a.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyStatus), b.(*admissionregistration.ValidatingAdmissionPolicyStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyStatus)(nil), (*admissionregistrationv1alpha1.ValidatingAdmissionPolicyStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1alpha1_ValidatingAdmissionPolicyStatus(a.(*admissionregistration.ValidatingAdmissionPolicyStatus), b.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.Validation)(nil), (*admissionregistration.Validation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_Validation_To_admissionregistration_Validation(a.(*admissionregistrationv1alpha1.Validation), b.(*admissionregistration.Validation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Validation)(nil), (*admissionregistrationv1alpha1.Validation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Validation_To_v1alpha1_Validation(a.(*admissionregistration.Validation), b.(*admissionregistrationv1alpha1.Validation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1alpha1.Variable)(nil), (*admissionregistration.Variable)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_Variable_To_admissionregistration_Variable(a.(*admissionregistrationv1alpha1.Variable), b.(*admissionregistration.Variable), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Variable)(nil), (*admissionregistrationv1alpha1.Variable)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Variable_To_v1alpha1_Variable(a.(*admissionregistration.Variable), b.(*admissionregistrationv1alpha1.Variable), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1alpha1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration(in *admissionregistrationv1alpha1.ApplyConfiguration, out *admissionregistration.ApplyConfiguration, s conversion.Scope) error {
        out.Expression = in.Expression
        return nil
}

// Convert_v1alpha1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration is an autogenerated conversion function.
func Convert_v1alpha1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration(in *admissionregistrationv1alpha1.ApplyConfiguration, out *admissionregistration.ApplyConfiguration, s conversion.Scope) error {
        return autoConvert_v1alpha1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration(in, out, s)
}

func autoConvert_admissionregistration_ApplyConfiguration_To_v1alpha1_ApplyConfiguration(in *admissionregistration.ApplyConfiguration, out *admissionregistrationv1alpha1.ApplyConfiguration, s conversion.Scope) error {
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_ApplyConfiguration_To_v1alpha1_ApplyConfiguration is an autogenerated conversion function.
func Convert_admissionregistration_ApplyConfiguration_To_v1alpha1_ApplyConfiguration(in *admissionregistration.ApplyConfiguration, out *admissionregistrationv1alpha1.ApplyConfiguration, s conversion.Scope) error {
        return autoConvert_admissionregistration_ApplyConfiguration_To_v1alpha1_ApplyConfiguration(in, out, s)
}

func autoConvert_v1alpha1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in *admissionregistrationv1alpha1.AuditAnnotation, out *admissionregistration.AuditAnnotation, s conversion.Scope) error {
        out.Key = in.Key
        out.ValueExpression = in.ValueExpression
        return nil
}

// Convert_v1alpha1_AuditAnnotation_To_admissionregistration_AuditAnnotation is an autogenerated conversion function.
func Convert_v1alpha1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in *admissionregistrationv1alpha1.AuditAnnotation, out *admissionregistration.AuditAnnotation, s conversion.Scope) error {
        return autoConvert_v1alpha1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in, out, s)
}

func autoConvert_admissionregistration_AuditAnnotation_To_v1alpha1_AuditAnnotation(in *admissionregistration.AuditAnnotation, out *admissionregistrationv1alpha1.AuditAnnotation, s conversion.Scope) error {
        out.Key = in.Key
        out.ValueExpression = in.ValueExpression
        return nil
}

// Convert_admissionregistration_AuditAnnotation_To_v1alpha1_AuditAnnotation is an autogenerated conversion function.
func Convert_admissionregistration_AuditAnnotation_To_v1alpha1_AuditAnnotation(in *admissionregistration.AuditAnnotation, out *admissionregistrationv1alpha1.AuditAnnotation, s conversion.Scope) error {
        return autoConvert_admissionregistration_AuditAnnotation_To_v1alpha1_AuditAnnotation(in, out, s)
}

func autoConvert_v1alpha1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in *admissionregistrationv1alpha1.ExpressionWarning, out *admissionregistration.ExpressionWarning, s conversion.Scope) error {
        out.FieldRef = in.FieldRef
        out.Warning = in.Warning
        return nil
}

// Convert_v1alpha1_ExpressionWarning_To_admissionregistration_ExpressionWarning is an autogenerated conversion function.
func Convert_v1alpha1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in *admissionregistrationv1alpha1.ExpressionWarning, out *admissionregistration.ExpressionWarning, s conversion.Scope) error {
        return autoConvert_v1alpha1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in, out, s)
}

func autoConvert_admissionregistration_ExpressionWarning_To_v1alpha1_ExpressionWarning(in *admissionregistration.ExpressionWarning, out *admissionregistrationv1alpha1.ExpressionWarning, s conversion.Scope) error {
        out.FieldRef = in.FieldRef
        out.Warning = in.Warning
        return nil
}

// Convert_admissionregistration_ExpressionWarning_To_v1alpha1_ExpressionWarning is an autogenerated conversion function.
func Convert_admissionregistration_ExpressionWarning_To_v1alpha1_ExpressionWarning(in *admissionregistration.ExpressionWarning, out *admissionregistrationv1alpha1.ExpressionWarning, s conversion.Scope) error {
        return autoConvert_admissionregistration_ExpressionWarning_To_v1alpha1_ExpressionWarning(in, out, s)
}

func autoConvert_v1alpha1_JSONPatch_To_admissionregistration_JSONPatch(in *admissionregistrationv1alpha1.JSONPatch, out *admissionregistration.JSONPatch, s conversion.Scope) error {
        out.Expression = in.Expression
        return nil
}

// Convert_v1alpha1_JSONPatch_To_admissionregistration_JSONPatch is an autogenerated conversion function.
func Convert_v1alpha1_JSONPatch_To_admissionregistration_JSONPatch(in *admissionregistrationv1alpha1.JSONPatch, out *admissionregistration.JSONPatch, s conversion.Scope) error {
        return autoConvert_v1alpha1_JSONPatch_To_admissionregistration_JSONPatch(in, out, s)
}

func autoConvert_admissionregistration_JSONPatch_To_v1alpha1_JSONPatch(in *admissionregistration.JSONPatch, out *admissionregistrationv1alpha1.JSONPatch, s conversion.Scope) error {
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_JSONPatch_To_v1alpha1_JSONPatch is an autogenerated conversion function.
func Convert_admissionregistration_JSONPatch_To_v1alpha1_JSONPatch(in *admissionregistration.JSONPatch, out *admissionregistrationv1alpha1.JSONPatch, s conversion.Scope) error {
        return autoConvert_admissionregistration_JSONPatch_To_v1alpha1_JSONPatch(in, out, s)
}

func autoConvert_v1alpha1_MatchCondition_To_admissionregistration_MatchCondition(in *admissionregistrationv1alpha1.MatchCondition, out *admissionregistration.MatchCondition, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_v1alpha1_MatchCondition_To_admissionregistration_MatchCondition is an autogenerated conversion function.
func Convert_v1alpha1_MatchCondition_To_admissionregistration_MatchCondition(in *admissionregistrationv1alpha1.MatchCondition, out *admissionregistration.MatchCondition, s conversion.Scope) error {
        return autoConvert_v1alpha1_MatchCondition_To_admissionregistration_MatchCondition(in, out, s)
}

func autoConvert_admissionregistration_MatchCondition_To_v1alpha1_MatchCondition(in *admissionregistration.MatchCondition, out *admissionregistrationv1alpha1.MatchCondition, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_MatchCondition_To_v1alpha1_MatchCondition is an autogenerated conversion function.
func Convert_admissionregistration_MatchCondition_To_v1alpha1_MatchCondition(in *admissionregistration.MatchCondition, out *admissionregistrationv1alpha1.MatchCondition, s conversion.Scope) error {
        return autoConvert_admissionregistration_MatchCondition_To_v1alpha1_MatchCondition(in, out, s)
}

func autoConvert_v1alpha1_MatchResources_To_admissionregistration_MatchResources(in *admissionregistrationv1alpha1.MatchResources, out *admissionregistration.MatchResources, s conversion.Scope) error {
        out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        if in.ResourceRules != nil {
                in, out := &in.ResourceRules, &out.ResourceRules
                *out = make([]admissionregistration.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_v1alpha1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ResourceRules = nil
        }
        if in.ExcludeResourceRules != nil {
                in, out := &in.ExcludeResourceRules, &out.ExcludeResourceRules
                *out = make([]admissionregistration.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_v1alpha1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ExcludeResourceRules = nil
        }
        out.MatchPolicy = (*admissionregistration.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        return nil
}

// Convert_v1alpha1_MatchResources_To_admissionregistration_MatchResources is an autogenerated conversion function.
func Convert_v1alpha1_MatchResources_To_admissionregistration_MatchResources(in *admissionregistrationv1alpha1.MatchResources, out *admissionregistration.MatchResources, s conversion.Scope) error {
        return autoConvert_v1alpha1_MatchResources_To_admissionregistration_MatchResources(in, out, s)
}

func autoConvert_admissionregistration_MatchResources_To_v1alpha1_MatchResources(in *admissionregistration.MatchResources, out *admissionregistrationv1alpha1.MatchResources, s conversion.Scope) error {
        out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        if in.ResourceRules != nil {
                in, out := &in.ResourceRules, &out.ResourceRules
                *out = make([]admissionregistrationv1alpha1.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_NamedRuleWithOperations_To_v1alpha1_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ResourceRules = nil
        }
        if in.ExcludeResourceRules != nil {
                in, out := &in.ExcludeResourceRules, &out.ExcludeResourceRules
                *out = make([]admissionregistrationv1alpha1.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_NamedRuleWithOperations_To_v1alpha1_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ExcludeResourceRules = nil
        }
        out.MatchPolicy = (*admissionregistrationv1alpha1.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        return nil
}

// Convert_admissionregistration_MatchResources_To_v1alpha1_MatchResources is an autogenerated conversion function.
func Convert_admissionregistration_MatchResources_To_v1alpha1_MatchResources(in *admissionregistration.MatchResources, out *admissionregistrationv1alpha1.MatchResources, s conversion.Scope) error {
        return autoConvert_admissionregistration_MatchResources_To_v1alpha1_MatchResources(in, out, s)
}

func autoConvert_v1alpha1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(in *admissionregistrationv1alpha1.MutatingAdmissionPolicy, out *admissionregistration.MutatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1alpha1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy is an autogenerated conversion function.
func Convert_v1alpha1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(in *admissionregistrationv1alpha1.MutatingAdmissionPolicy, out *admissionregistration.MutatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_v1alpha1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicy_To_v1alpha1_MutatingAdmissionPolicy(in *admissionregistration.MutatingAdmissionPolicy, out *admissionregistrationv1alpha1.MutatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_MutatingAdmissionPolicySpec_To_v1alpha1_MutatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicy_To_v1alpha1_MutatingAdmissionPolicy is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicy_To_v1alpha1_MutatingAdmissionPolicy(in *admissionregistration.MutatingAdmissionPolicy, out *admissionregistrationv1alpha1.MutatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicy_To_v1alpha1_MutatingAdmissionPolicy(in, out, s)
}

func autoConvert_v1alpha1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding, out *admissionregistration.MutatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1alpha1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_v1alpha1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding, out *admissionregistration.MutatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_v1alpha1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1alpha1_MutatingAdmissionPolicyBinding(in *admissionregistration.MutatingAdmissionPolicyBinding, out *admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1alpha1_MutatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1alpha1_MutatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1alpha1_MutatingAdmissionPolicyBinding(in *admissionregistration.MutatingAdmissionPolicyBinding, out *admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1alpha1_MutatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_v1alpha1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList, out *admissionregistration.MutatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.MutatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_v1alpha1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1alpha1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_v1alpha1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList, out *admissionregistration.MutatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_v1alpha1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1alpha1_MutatingAdmissionPolicyBindingList(in *admissionregistration.MutatingAdmissionPolicyBindingList, out *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1alpha1_MutatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1alpha1_MutatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1alpha1_MutatingAdmissionPolicyBindingList(in *admissionregistration.MutatingAdmissionPolicyBindingList, out *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1alpha1_MutatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_v1alpha1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingSpec, out *admissionregistration.MutatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistration.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1alpha1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        return nil
}

// Convert_v1alpha1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_v1alpha1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingSpec, out *admissionregistration.MutatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_v1alpha1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1alpha1_MutatingAdmissionPolicyBindingSpec(in *admissionregistration.MutatingAdmissionPolicyBindingSpec, out *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistrationv1alpha1.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistrationv1alpha1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1alpha1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1alpha1_MutatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1alpha1_MutatingAdmissionPolicyBindingSpec(in *admissionregistration.MutatingAdmissionPolicyBindingSpec, out *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1alpha1_MutatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_v1alpha1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyList, out *admissionregistration.MutatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.MutatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_v1alpha1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1alpha1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_v1alpha1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyList, out *admissionregistration.MutatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_v1alpha1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicyList_To_v1alpha1_MutatingAdmissionPolicyList(in *admissionregistration.MutatingAdmissionPolicyList, out *admissionregistrationv1alpha1.MutatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1alpha1.MutatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_MutatingAdmissionPolicy_To_v1alpha1_MutatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicyList_To_v1alpha1_MutatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicyList_To_v1alpha1_MutatingAdmissionPolicyList(in *admissionregistration.MutatingAdmissionPolicyList, out *admissionregistrationv1alpha1.MutatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicyList_To_v1alpha1_MutatingAdmissionPolicyList(in, out, s)
}

func autoConvert_v1alpha1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(in *admissionregistrationv1alpha1.MutatingAdmissionPolicySpec, out *admissionregistration.MutatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistration.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1alpha1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Variables = *(*[]admissionregistration.Variable)(unsafe.Pointer(&in.Variables))
        out.Mutations = *(*[]admissionregistration.Mutation)(unsafe.Pointer(&in.Mutations))
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.ReinvocationPolicy = admissionregistration.ReinvocationPolicyType(in.ReinvocationPolicy)
        return nil
}

// Convert_v1alpha1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_v1alpha1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(in *admissionregistrationv1alpha1.MutatingAdmissionPolicySpec, out *admissionregistration.MutatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_v1alpha1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicySpec_To_v1alpha1_MutatingAdmissionPolicySpec(in *admissionregistration.MutatingAdmissionPolicySpec, out *admissionregistrationv1alpha1.MutatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistrationv1alpha1.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistrationv1alpha1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1alpha1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Variables = *(*[]admissionregistrationv1alpha1.Variable)(unsafe.Pointer(&in.Variables))
        out.Mutations = *(*[]admissionregistrationv1alpha1.Mutation)(unsafe.Pointer(&in.Mutations))
        out.FailurePolicy = (*admissionregistrationv1alpha1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchConditions = *(*[]admissionregistrationv1alpha1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.ReinvocationPolicy = admissionregistrationv1.ReinvocationPolicyType(in.ReinvocationPolicy)
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicySpec_To_v1alpha1_MutatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicySpec_To_v1alpha1_MutatingAdmissionPolicySpec(in *admissionregistration.MutatingAdmissionPolicySpec, out *admissionregistrationv1alpha1.MutatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicySpec_To_v1alpha1_MutatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_v1alpha1_Mutation_To_admissionregistration_Mutation(in *admissionregistrationv1alpha1.Mutation, out *admissionregistration.Mutation, s conversion.Scope) error {
        out.PatchType = admissionregistration.PatchType(in.PatchType)
        out.ApplyConfiguration = (*admissionregistration.ApplyConfiguration)(unsafe.Pointer(in.ApplyConfiguration))
        out.JSONPatch = (*admissionregistration.JSONPatch)(unsafe.Pointer(in.JSONPatch))
        return nil
}

// Convert_v1alpha1_Mutation_To_admissionregistration_Mutation is an autogenerated conversion function.
func Convert_v1alpha1_Mutation_To_admissionregistration_Mutation(in *admissionregistrationv1alpha1.Mutation, out *admissionregistration.Mutation, s conversion.Scope) error {
        return autoConvert_v1alpha1_Mutation_To_admissionregistration_Mutation(in, out, s)
}

func autoConvert_admissionregistration_Mutation_To_v1alpha1_Mutation(in *admissionregistration.Mutation, out *admissionregistrationv1alpha1.Mutation, s conversion.Scope) error {
        out.PatchType = admissionregistrationv1alpha1.PatchType(in.PatchType)
        out.ApplyConfiguration = (*admissionregistrationv1alpha1.ApplyConfiguration)(unsafe.Pointer(in.ApplyConfiguration))
        out.JSONPatch = (*admissionregistrationv1alpha1.JSONPatch)(unsafe.Pointer(in.JSONPatch))
        return nil
}

// Convert_admissionregistration_Mutation_To_v1alpha1_Mutation is an autogenerated conversion function.
func Convert_admissionregistration_Mutation_To_v1alpha1_Mutation(in *admissionregistration.Mutation, out *admissionregistrationv1alpha1.Mutation, s conversion.Scope) error {
        return autoConvert_admissionregistration_Mutation_To_v1alpha1_Mutation(in, out, s)
}

func autoConvert_v1alpha1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in *admissionregistrationv1alpha1.NamedRuleWithOperations, out *admissionregistration.NamedRuleWithOperations, s conversion.Scope) error {
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        if err := apisadmissionregistrationv1.Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(&in.RuleWithOperations, &out.RuleWithOperations, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations is an autogenerated conversion function.
func Convert_v1alpha1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in *admissionregistrationv1alpha1.NamedRuleWithOperations, out *admissionregistration.NamedRuleWithOperations, s conversion.Scope) error {
        return autoConvert_v1alpha1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in, out, s)
}

func autoConvert_admissionregistration_NamedRuleWithOperations_To_v1alpha1_NamedRuleWithOperations(in *admissionregistration.NamedRuleWithOperations, out *admissionregistrationv1alpha1.NamedRuleWithOperations, s conversion.Scope) error {
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        if err := apisadmissionregistrationv1.Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(&in.RuleWithOperations, &out.RuleWithOperations, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_NamedRuleWithOperations_To_v1alpha1_NamedRuleWithOperations is an autogenerated conversion function.
func Convert_admissionregistration_NamedRuleWithOperations_To_v1alpha1_NamedRuleWithOperations(in *admissionregistration.NamedRuleWithOperations, out *admissionregistrationv1alpha1.NamedRuleWithOperations, s conversion.Scope) error {
        return autoConvert_admissionregistration_NamedRuleWithOperations_To_v1alpha1_NamedRuleWithOperations(in, out, s)
}

func autoConvert_v1alpha1_ParamKind_To_admissionregistration_ParamKind(in *admissionregistrationv1alpha1.ParamKind, out *admissionregistration.ParamKind, s conversion.Scope) error {
        out.APIVersion = in.APIVersion
        out.Kind = in.Kind
        return nil
}

// Convert_v1alpha1_ParamKind_To_admissionregistration_ParamKind is an autogenerated conversion function.
func Convert_v1alpha1_ParamKind_To_admissionregistration_ParamKind(in *admissionregistrationv1alpha1.ParamKind, out *admissionregistration.ParamKind, s conversion.Scope) error {
        return autoConvert_v1alpha1_ParamKind_To_admissionregistration_ParamKind(in, out, s)
}

func autoConvert_admissionregistration_ParamKind_To_v1alpha1_ParamKind(in *admissionregistration.ParamKind, out *admissionregistrationv1alpha1.ParamKind, s conversion.Scope) error {
        out.APIVersion = in.APIVersion
        out.Kind = in.Kind
        return nil
}

// Convert_admissionregistration_ParamKind_To_v1alpha1_ParamKind is an autogenerated conversion function.
func Convert_admissionregistration_ParamKind_To_v1alpha1_ParamKind(in *admissionregistration.ParamKind, out *admissionregistrationv1alpha1.ParamKind, s conversion.Scope) error {
        return autoConvert_admissionregistration_ParamKind_To_v1alpha1_ParamKind(in, out, s)
}

func autoConvert_v1alpha1_ParamRef_To_admissionregistration_ParamRef(in *admissionregistrationv1alpha1.ParamRef, out *admissionregistration.ParamRef, s conversion.Scope) error {
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Selector = (*v1.LabelSelector)(unsafe.Pointer(in.Selector))
        out.ParameterNotFoundAction = (*admissionregistration.ParameterNotFoundActionType)(unsafe.Pointer(in.ParameterNotFoundAction))
        return nil
}

// Convert_v1alpha1_ParamRef_To_admissionregistration_ParamRef is an autogenerated conversion function.
func Convert_v1alpha1_ParamRef_To_admissionregistration_ParamRef(in *admissionregistrationv1alpha1.ParamRef, out *admissionregistration.ParamRef, s conversion.Scope) error {
        return autoConvert_v1alpha1_ParamRef_To_admissionregistration_ParamRef(in, out, s)
}

func autoConvert_admissionregistration_ParamRef_To_v1alpha1_ParamRef(in *admissionregistration.ParamRef, out *admissionregistrationv1alpha1.ParamRef, s conversion.Scope) error {
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Selector = (*v1.LabelSelector)(unsafe.Pointer(in.Selector))
        out.ParameterNotFoundAction = (*admissionregistrationv1alpha1.ParameterNotFoundActionType)(unsafe.Pointer(in.ParameterNotFoundAction))
        return nil
}

// Convert_admissionregistration_ParamRef_To_v1alpha1_ParamRef is an autogenerated conversion function.
func Convert_admissionregistration_ParamRef_To_v1alpha1_ParamRef(in *admissionregistration.ParamRef, out *admissionregistrationv1alpha1.ParamRef, s conversion.Scope) error {
        return autoConvert_admissionregistration_ParamRef_To_v1alpha1_ParamRef(in, out, s)
}

func autoConvert_v1alpha1_TypeChecking_To_admissionregistration_TypeChecking(in *admissionregistrationv1alpha1.TypeChecking, out *admissionregistration.TypeChecking, s conversion.Scope) error {
        out.ExpressionWarnings = *(*[]admissionregistration.ExpressionWarning)(unsafe.Pointer(&in.ExpressionWarnings))
        return nil
}

// Convert_v1alpha1_TypeChecking_To_admissionregistration_TypeChecking is an autogenerated conversion function.
func Convert_v1alpha1_TypeChecking_To_admissionregistration_TypeChecking(in *admissionregistrationv1alpha1.TypeChecking, out *admissionregistration.TypeChecking, s conversion.Scope) error {
        return autoConvert_v1alpha1_TypeChecking_To_admissionregistration_TypeChecking(in, out, s)
}

func autoConvert_admissionregistration_TypeChecking_To_v1alpha1_TypeChecking(in *admissionregistration.TypeChecking, out *admissionregistrationv1alpha1.TypeChecking, s conversion.Scope) error {
        out.ExpressionWarnings = *(*[]admissionregistrationv1alpha1.ExpressionWarning)(unsafe.Pointer(&in.ExpressionWarnings))
        return nil
}

// Convert_admissionregistration_TypeChecking_To_v1alpha1_TypeChecking is an autogenerated conversion function.
func Convert_admissionregistration_TypeChecking_To_v1alpha1_TypeChecking(in *admissionregistration.TypeChecking, out *admissionregistrationv1alpha1.TypeChecking, s conversion.Scope) error {
        return autoConvert_admissionregistration_TypeChecking_To_v1alpha1_TypeChecking(in, out, s)
}

func autoConvert_v1alpha1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicy, out *admissionregistration.ValidatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1alpha1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1alpha1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy is an autogenerated conversion function.
func Convert_v1alpha1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicy, out *admissionregistration.ValidatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_v1alpha1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicy_To_v1alpha1_ValidatingAdmissionPolicy(in *admissionregistration.ValidatingAdmissionPolicy, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1alpha1_ValidatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1alpha1_ValidatingAdmissionPolicyStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1alpha1_ValidatingAdmissionPolicy is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1alpha1_ValidatingAdmissionPolicy(in *admissionregistration.ValidatingAdmissionPolicy, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicy_To_v1alpha1_ValidatingAdmissionPolicy(in, out, s)
}

func autoConvert_v1alpha1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding, out *admissionregistration.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1alpha1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_v1alpha1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding, out *admissionregistration.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_v1alpha1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1alpha1_ValidatingAdmissionPolicyBinding(in *admissionregistration.ValidatingAdmissionPolicyBinding, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1alpha1_ValidatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1alpha1_ValidatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1alpha1_ValidatingAdmissionPolicyBinding(in *admissionregistration.ValidatingAdmissionPolicyBinding, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1alpha1_ValidatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_v1alpha1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList, out *admissionregistration.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.ValidatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_v1alpha1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1alpha1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_v1alpha1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList, out *admissionregistration.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_v1alpha1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1alpha1_ValidatingAdmissionPolicyBindingList(in *admissionregistration.ValidatingAdmissionPolicyBindingList, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1alpha1_ValidatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1alpha1_ValidatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1alpha1_ValidatingAdmissionPolicyBindingList(in *admissionregistration.ValidatingAdmissionPolicyBindingList, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1alpha1_ValidatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_v1alpha1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingSpec, out *admissionregistration.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistration.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1alpha1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        out.ValidationActions = *(*[]admissionregistration.ValidationAction)(unsafe.Pointer(&in.ValidationActions))
        return nil
}

// Convert_v1alpha1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_v1alpha1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingSpec, out *admissionregistration.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_v1alpha1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1alpha1_ValidatingAdmissionPolicyBindingSpec(in *admissionregistration.ValidatingAdmissionPolicyBindingSpec, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistrationv1alpha1.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistrationv1alpha1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1alpha1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        out.ValidationActions = *(*[]admissionregistrationv1alpha1.ValidationAction)(unsafe.Pointer(&in.ValidationActions))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1alpha1_ValidatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1alpha1_ValidatingAdmissionPolicyBindingSpec(in *admissionregistration.ValidatingAdmissionPolicyBindingSpec, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1alpha1_ValidatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_v1alpha1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyList, out *admissionregistration.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.ValidatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_v1alpha1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1alpha1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_v1alpha1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyList, out *admissionregistration.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_v1alpha1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyList_To_v1alpha1_ValidatingAdmissionPolicyList(in *admissionregistration.ValidatingAdmissionPolicyList, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1alpha1.ValidatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1alpha1_ValidatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1alpha1_ValidatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1alpha1_ValidatingAdmissionPolicyList(in *admissionregistration.ValidatingAdmissionPolicyList, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyList_To_v1alpha1_ValidatingAdmissionPolicyList(in, out, s)
}

func autoConvert_v1alpha1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec, out *admissionregistration.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistration.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1alpha1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Validations = *(*[]admissionregistration.Validation)(unsafe.Pointer(&in.Validations))
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.AuditAnnotations = *(*[]admissionregistration.AuditAnnotation)(unsafe.Pointer(&in.AuditAnnotations))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.Variables = *(*[]admissionregistration.Variable)(unsafe.Pointer(&in.Variables))
        return nil
}

// Convert_v1alpha1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_v1alpha1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec, out *admissionregistration.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_v1alpha1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1alpha1_ValidatingAdmissionPolicySpec(in *admissionregistration.ValidatingAdmissionPolicySpec, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistrationv1alpha1.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistrationv1alpha1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1alpha1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Validations = *(*[]admissionregistrationv1alpha1.Validation)(unsafe.Pointer(&in.Validations))
        out.MatchConditions = *(*[]admissionregistrationv1alpha1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.FailurePolicy = (*admissionregistrationv1alpha1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.AuditAnnotations = *(*[]admissionregistrationv1alpha1.AuditAnnotation)(unsafe.Pointer(&in.AuditAnnotations))
        out.Variables = *(*[]admissionregistrationv1alpha1.Variable)(unsafe.Pointer(&in.Variables))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1alpha1_ValidatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1alpha1_ValidatingAdmissionPolicySpec(in *admissionregistration.ValidatingAdmissionPolicySpec, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1alpha1_ValidatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_v1alpha1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyStatus, out *admissionregistration.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.TypeChecking = (*admissionregistration.TypeChecking)(unsafe.Pointer(in.TypeChecking))
        out.Conditions = *(*[]v1.Condition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1alpha1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus is an autogenerated conversion function.
func Convert_v1alpha1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyStatus, out *admissionregistration.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        return autoConvert_v1alpha1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1alpha1_ValidatingAdmissionPolicyStatus(in *admissionregistration.ValidatingAdmissionPolicyStatus, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.TypeChecking = (*admissionregistrationv1alpha1.TypeChecking)(unsafe.Pointer(in.TypeChecking))
        out.Conditions = *(*[]v1.Condition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1alpha1_ValidatingAdmissionPolicyStatus is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1alpha1_ValidatingAdmissionPolicyStatus(in *admissionregistration.ValidatingAdmissionPolicyStatus, out *admissionregistrationv1alpha1.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1alpha1_ValidatingAdmissionPolicyStatus(in, out, s)
}

func autoConvert_v1alpha1_Validation_To_admissionregistration_Validation(in *admissionregistrationv1alpha1.Validation, out *admissionregistration.Validation, s conversion.Scope) error {
        out.Expression = in.Expression
        out.Message = in.Message
        out.Reason = (*v1.StatusReason)(unsafe.Pointer(in.Reason))
        out.MessageExpression = in.MessageExpression
        return nil
}

// Convert_v1alpha1_Validation_To_admissionregistration_Validation is an autogenerated conversion function.
func Convert_v1alpha1_Validation_To_admissionregistration_Validation(in *admissionregistrationv1alpha1.Validation, out *admissionregistration.Validation, s conversion.Scope) error {
        return autoConvert_v1alpha1_Validation_To_admissionregistration_Validation(in, out, s)
}

func autoConvert_admissionregistration_Validation_To_v1alpha1_Validation(in *admissionregistration.Validation, out *admissionregistrationv1alpha1.Validation, s conversion.Scope) error {
        out.Expression = in.Expression
        out.Message = in.Message
        out.Reason = (*v1.StatusReason)(unsafe.Pointer(in.Reason))
        out.MessageExpression = in.MessageExpression
        return nil
}

// Convert_admissionregistration_Validation_To_v1alpha1_Validation is an autogenerated conversion function.
func Convert_admissionregistration_Validation_To_v1alpha1_Validation(in *admissionregistration.Validation, out *admissionregistrationv1alpha1.Validation, s conversion.Scope) error {
        return autoConvert_admissionregistration_Validation_To_v1alpha1_Validation(in, out, s)
}

func autoConvert_v1alpha1_Variable_To_admissionregistration_Variable(in *admissionregistrationv1alpha1.Variable, out *admissionregistration.Variable, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_v1alpha1_Variable_To_admissionregistration_Variable is an autogenerated conversion function.
func Convert_v1alpha1_Variable_To_admissionregistration_Variable(in *admissionregistrationv1alpha1.Variable, out *admissionregistration.Variable, s conversion.Scope) error {
        return autoConvert_v1alpha1_Variable_To_admissionregistration_Variable(in, out, s)
}

func autoConvert_admissionregistration_Variable_To_v1alpha1_Variable(in *admissionregistration.Variable, out *admissionregistrationv1alpha1.Variable, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_Variable_To_v1alpha1_Variable is an autogenerated conversion function.
func Convert_admissionregistration_Variable_To_v1alpha1_Variable(in *admissionregistration.Variable, out *admissionregistrationv1alpha1.Variable, s conversion.Scope) error {
        return autoConvert_admissionregistration_Variable_To_v1alpha1_Variable(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1alpha1

import (
        admissionregistrationv1alpha1 "k8s.io/api/admissionregistration/v1alpha1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        v1 "k8s.io/kubernetes/pkg/apis/admissionregistration/v1"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1alpha1.MutatingAdmissionPolicy{}, func(obj interface{}) {
                SetObjectDefaults_MutatingAdmissionPolicy(obj.(*admissionregistrationv1alpha1.MutatingAdmissionPolicy))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding{}, func(obj interface{}) {
                SetObjectDefaults_MutatingAdmissionPolicyBinding(obj.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList{}, func(obj interface{}) {
                SetObjectDefaults_MutatingAdmissionPolicyBindingList(obj.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1alpha1.MutatingAdmissionPolicyList{}, func(obj interface{}) {
                SetObjectDefaults_MutatingAdmissionPolicyList(obj.(*admissionregistrationv1alpha1.MutatingAdmissionPolicyList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1alpha1.ValidatingAdmissionPolicy{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicy(obj.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicy))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyBinding(obj.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyBindingList(obj.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1alpha1.ValidatingAdmissionPolicyList{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyList(obj.(*admissionregistrationv1alpha1.ValidatingAdmissionPolicyList))
        })
        return nil
}

func SetObjectDefaults_MutatingAdmissionPolicy(in *admissionregistrationv1alpha1.MutatingAdmissionPolicy) {
        SetDefaults_MutatingAdmissionPolicySpec(&in.Spec)
        if in.Spec.MatchConstraints != nil {
                SetDefaults_MatchResources(in.Spec.MatchConstraints)
                for i := range in.Spec.MatchConstraints.ResourceRules {
                        a := &in.Spec.MatchConstraints.ResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchConstraints.ExcludeResourceRules {
                        a := &in.Spec.MatchConstraints.ExcludeResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_MutatingAdmissionPolicyBinding(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyBinding) {
        if in.Spec.ParamRef != nil {
                SetDefaults_ParamRef(in.Spec.ParamRef)
        }
        if in.Spec.MatchResources != nil {
                SetDefaults_MatchResources(in.Spec.MatchResources)
                for i := range in.Spec.MatchResources.ResourceRules {
                        a := &in.Spec.MatchResources.ResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchResources.ExcludeResourceRules {
                        a := &in.Spec.MatchResources.ExcludeResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_MutatingAdmissionPolicyBindingList(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyBindingList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_MutatingAdmissionPolicyBinding(a)
        }
}

func SetObjectDefaults_MutatingAdmissionPolicyList(in *admissionregistrationv1alpha1.MutatingAdmissionPolicyList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_MutatingAdmissionPolicy(a)
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicy(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicy) {
        SetDefaults_ValidatingAdmissionPolicySpec(&in.Spec)
        if in.Spec.MatchConstraints != nil {
                SetDefaults_MatchResources(in.Spec.MatchConstraints)
                for i := range in.Spec.MatchConstraints.ResourceRules {
                        a := &in.Spec.MatchConstraints.ResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchConstraints.ExcludeResourceRules {
                        a := &in.Spec.MatchConstraints.ExcludeResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBinding) {
        if in.Spec.ParamRef != nil {
                SetDefaults_ParamRef(in.Spec.ParamRef)
        }
        if in.Spec.MatchResources != nil {
                SetDefaults_MatchResources(in.Spec.MatchResources)
                for i := range in.Spec.MatchResources.ResourceRules {
                        a := &in.Spec.MatchResources.ResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchResources.ExcludeResourceRules {
                        a := &in.Spec.MatchResources.ExcludeResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyBindingList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ValidatingAdmissionPolicyBinding(a)
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyList(in *admissionregistrationv1alpha1.ValidatingAdmissionPolicyList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ValidatingAdmissionPolicy(a)
        }
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/utils/ptr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

// SetDefaults_ValidatingAdmissionPolicySpec sets defaults for ValidatingAdmissionPolicySpec
func SetDefaults_ValidatingAdmissionPolicySpec(obj *admissionregistrationv1beta1.ValidatingAdmissionPolicySpec) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1beta1.Fail
                obj.FailurePolicy = &policy
        }
}

// SetDefaults_MatchResources sets defaults for MatchResources
func SetDefaults_MatchResources(obj *admissionregistrationv1beta1.MatchResources) {
        if obj.MatchPolicy == nil {
                policy := admissionregistrationv1beta1.Equivalent
                obj.MatchPolicy = &policy
        }
        if obj.NamespaceSelector == nil {
                selector := metav1.LabelSelector{}
                obj.NamespaceSelector = &selector
        }
        if obj.ObjectSelector == nil {
                selector := metav1.LabelSelector{}
                obj.ObjectSelector = &selector
        }
}

// SetDefaults_ValidatingWebhook sets defaults for webhook validating
func SetDefaults_ValidatingWebhook(obj *admissionregistrationv1beta1.ValidatingWebhook) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1beta1.Ignore
                obj.FailurePolicy = &policy
        }
        if obj.MatchPolicy == nil {
                policy := admissionregistrationv1beta1.Exact
                obj.MatchPolicy = &policy
        }
        if obj.NamespaceSelector == nil {
                selector := metav1.LabelSelector{}
                obj.NamespaceSelector = &selector
        }
        if obj.ObjectSelector == nil {
                selector := metav1.LabelSelector{}
                obj.ObjectSelector = &selector
        }
        if obj.SideEffects == nil {
                // TODO: revisit/remove this default and possibly make the field required when promoting to v1
                unknown := admissionregistrationv1beta1.SideEffectClassUnknown
                obj.SideEffects = &unknown
        }
        if obj.TimeoutSeconds == nil {
                obj.TimeoutSeconds = new(int32)
                *obj.TimeoutSeconds = 30
        }

        if len(obj.AdmissionReviewVersions) == 0 {
                obj.AdmissionReviewVersions = []string{admissionregistrationv1beta1.SchemeGroupVersion.Version}
        }
}

// SetDefaults_MutatingWebhook sets defaults for webhook mutating
func SetDefaults_MutatingWebhook(obj *admissionregistrationv1beta1.MutatingWebhook) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1beta1.Ignore
                obj.FailurePolicy = &policy
        }
        if obj.MatchPolicy == nil {
                policy := admissionregistrationv1beta1.Exact
                obj.MatchPolicy = &policy
        }
        if obj.NamespaceSelector == nil {
                selector := metav1.LabelSelector{}
                obj.NamespaceSelector = &selector
        }
        if obj.ObjectSelector == nil {
                selector := metav1.LabelSelector{}
                obj.ObjectSelector = &selector
        }
        if obj.SideEffects == nil {
                // TODO: revisit/remove this default and possibly make the field required when promoting to v1
                unknown := admissionregistrationv1beta1.SideEffectClassUnknown
                obj.SideEffects = &unknown
        }
        if obj.TimeoutSeconds == nil {
                obj.TimeoutSeconds = new(int32)
                *obj.TimeoutSeconds = 30
        }
        if obj.ReinvocationPolicy == nil {
                never := admissionregistrationv1beta1.NeverReinvocationPolicy
                obj.ReinvocationPolicy = &never
        }

        if len(obj.AdmissionReviewVersions) == 0 {
                obj.AdmissionReviewVersions = []string{admissionregistrationv1beta1.SchemeGroupVersion.Version}
        }
}

// SetDefaults_ServiceReference sets defaults for Webhook's ServiceReference
func SetDefaults_ServiceReference(obj *admissionregistrationv1beta1.ServiceReference) {
        if obj.Port == nil {
                obj.Port = ptr.To[int32](443)
        }
}

// SetDefaults_MutatingAdmissionPolicySpec sets defaults for MutatingAdmissionPolicySpec
func SetDefaults_MutatingAdmissionPolicySpec(obj *admissionregistrationv1beta1.MutatingAdmissionPolicySpec) {
        if obj.FailurePolicy == nil {
                policy := admissionregistrationv1beta1.Fail
                obj.FailurePolicy = &policy
        }
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name used in this package
const GroupName = "admissionregistration.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &admissionregistrationv1beta1.SchemeBuilder
        // AddToScheme handler to add items to the schema
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        admissionregistrationv1 "k8s.io/api/admissionregistration/v1"
        admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1"
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        admissionregistration "k8s.io/kubernetes/pkg/apis/admissionregistration"
        apisadmissionregistrationv1 "k8s.io/kubernetes/pkg/apis/admissionregistration/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ApplyConfiguration)(nil), (*admissionregistration.ApplyConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration(a.(*admissionregistrationv1beta1.ApplyConfiguration), b.(*admissionregistration.ApplyConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ApplyConfiguration)(nil), (*admissionregistrationv1beta1.ApplyConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ApplyConfiguration_To_v1beta1_ApplyConfiguration(a.(*admissionregistration.ApplyConfiguration), b.(*admissionregistrationv1beta1.ApplyConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.AuditAnnotation)(nil), (*admissionregistration.AuditAnnotation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_AuditAnnotation_To_admissionregistration_AuditAnnotation(a.(*admissionregistrationv1beta1.AuditAnnotation), b.(*admissionregistration.AuditAnnotation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.AuditAnnotation)(nil), (*admissionregistrationv1beta1.AuditAnnotation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_AuditAnnotation_To_v1beta1_AuditAnnotation(a.(*admissionregistration.AuditAnnotation), b.(*admissionregistrationv1beta1.AuditAnnotation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ExpressionWarning)(nil), (*admissionregistration.ExpressionWarning)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ExpressionWarning_To_admissionregistration_ExpressionWarning(a.(*admissionregistrationv1beta1.ExpressionWarning), b.(*admissionregistration.ExpressionWarning), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ExpressionWarning)(nil), (*admissionregistrationv1beta1.ExpressionWarning)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ExpressionWarning_To_v1beta1_ExpressionWarning(a.(*admissionregistration.ExpressionWarning), b.(*admissionregistrationv1beta1.ExpressionWarning), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.JSONPatch)(nil), (*admissionregistration.JSONPatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_JSONPatch_To_admissionregistration_JSONPatch(a.(*admissionregistrationv1beta1.JSONPatch), b.(*admissionregistration.JSONPatch), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.JSONPatch)(nil), (*admissionregistrationv1beta1.JSONPatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_JSONPatch_To_v1beta1_JSONPatch(a.(*admissionregistration.JSONPatch), b.(*admissionregistrationv1beta1.JSONPatch), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MatchCondition)(nil), (*admissionregistration.MatchCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MatchCondition_To_admissionregistration_MatchCondition(a.(*admissionregistrationv1beta1.MatchCondition), b.(*admissionregistration.MatchCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MatchCondition)(nil), (*admissionregistrationv1beta1.MatchCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MatchCondition_To_v1beta1_MatchCondition(a.(*admissionregistration.MatchCondition), b.(*admissionregistrationv1beta1.MatchCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MatchResources)(nil), (*admissionregistration.MatchResources)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MatchResources_To_admissionregistration_MatchResources(a.(*admissionregistrationv1beta1.MatchResources), b.(*admissionregistration.MatchResources), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MatchResources)(nil), (*admissionregistrationv1beta1.MatchResources)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MatchResources_To_v1beta1_MatchResources(a.(*admissionregistration.MatchResources), b.(*admissionregistrationv1beta1.MatchResources), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingAdmissionPolicy)(nil), (*admissionregistration.MutatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(a.(*admissionregistrationv1beta1.MutatingAdmissionPolicy), b.(*admissionregistration.MutatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicy)(nil), (*admissionregistrationv1beta1.MutatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicy_To_v1beta1_MutatingAdmissionPolicy(a.(*admissionregistration.MutatingAdmissionPolicy), b.(*admissionregistrationv1beta1.MutatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingAdmissionPolicyBinding)(nil), (*admissionregistration.MutatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(a.(*admissionregistrationv1beta1.MutatingAdmissionPolicyBinding), b.(*admissionregistration.MutatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicyBinding)(nil), (*admissionregistrationv1beta1.MutatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1beta1_MutatingAdmissionPolicyBinding(a.(*admissionregistration.MutatingAdmissionPolicyBinding), b.(*admissionregistrationv1beta1.MutatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList)(nil), (*admissionregistration.MutatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList(a.(*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList), b.(*admissionregistration.MutatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicyBindingList)(nil), (*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1beta1_MutatingAdmissionPolicyBindingList(a.(*admissionregistration.MutatingAdmissionPolicyBindingList), b.(*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingSpec)(nil), (*admissionregistration.MutatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(a.(*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingSpec), b.(*admissionregistration.MutatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicyBindingSpec)(nil), (*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1beta1_MutatingAdmissionPolicyBindingSpec(a.(*admissionregistration.MutatingAdmissionPolicyBindingSpec), b.(*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingAdmissionPolicyList)(nil), (*admissionregistration.MutatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList(a.(*admissionregistrationv1beta1.MutatingAdmissionPolicyList), b.(*admissionregistration.MutatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicyList)(nil), (*admissionregistrationv1beta1.MutatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicyList_To_v1beta1_MutatingAdmissionPolicyList(a.(*admissionregistration.MutatingAdmissionPolicyList), b.(*admissionregistrationv1beta1.MutatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingAdmissionPolicySpec)(nil), (*admissionregistration.MutatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(a.(*admissionregistrationv1beta1.MutatingAdmissionPolicySpec), b.(*admissionregistration.MutatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingAdmissionPolicySpec)(nil), (*admissionregistrationv1beta1.MutatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingAdmissionPolicySpec_To_v1beta1_MutatingAdmissionPolicySpec(a.(*admissionregistration.MutatingAdmissionPolicySpec), b.(*admissionregistrationv1beta1.MutatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingWebhook)(nil), (*admissionregistration.MutatingWebhook)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingWebhook_To_admissionregistration_MutatingWebhook(a.(*admissionregistrationv1beta1.MutatingWebhook), b.(*admissionregistration.MutatingWebhook), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingWebhook)(nil), (*admissionregistrationv1beta1.MutatingWebhook)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingWebhook_To_v1beta1_MutatingWebhook(a.(*admissionregistration.MutatingWebhook), b.(*admissionregistrationv1beta1.MutatingWebhook), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingWebhookConfiguration)(nil), (*admissionregistration.MutatingWebhookConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(a.(*admissionregistrationv1beta1.MutatingWebhookConfiguration), b.(*admissionregistration.MutatingWebhookConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingWebhookConfiguration)(nil), (*admissionregistrationv1beta1.MutatingWebhookConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingWebhookConfiguration_To_v1beta1_MutatingWebhookConfiguration(a.(*admissionregistration.MutatingWebhookConfiguration), b.(*admissionregistrationv1beta1.MutatingWebhookConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.MutatingWebhookConfigurationList)(nil), (*admissionregistration.MutatingWebhookConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList(a.(*admissionregistrationv1beta1.MutatingWebhookConfigurationList), b.(*admissionregistration.MutatingWebhookConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.MutatingWebhookConfigurationList)(nil), (*admissionregistrationv1beta1.MutatingWebhookConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_MutatingWebhookConfigurationList_To_v1beta1_MutatingWebhookConfigurationList(a.(*admissionregistration.MutatingWebhookConfigurationList), b.(*admissionregistrationv1beta1.MutatingWebhookConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.Mutation)(nil), (*admissionregistration.Mutation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Mutation_To_admissionregistration_Mutation(a.(*admissionregistrationv1beta1.Mutation), b.(*admissionregistration.Mutation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Mutation)(nil), (*admissionregistrationv1beta1.Mutation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Mutation_To_v1beta1_Mutation(a.(*admissionregistration.Mutation), b.(*admissionregistrationv1beta1.Mutation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.NamedRuleWithOperations)(nil), (*admissionregistration.NamedRuleWithOperations)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(a.(*admissionregistrationv1beta1.NamedRuleWithOperations), b.(*admissionregistration.NamedRuleWithOperations), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.NamedRuleWithOperations)(nil), (*admissionregistrationv1beta1.NamedRuleWithOperations)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_NamedRuleWithOperations_To_v1beta1_NamedRuleWithOperations(a.(*admissionregistration.NamedRuleWithOperations), b.(*admissionregistrationv1beta1.NamedRuleWithOperations), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ParamKind)(nil), (*admissionregistration.ParamKind)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ParamKind_To_admissionregistration_ParamKind(a.(*admissionregistrationv1beta1.ParamKind), b.(*admissionregistration.ParamKind), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ParamKind)(nil), (*admissionregistrationv1beta1.ParamKind)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ParamKind_To_v1beta1_ParamKind(a.(*admissionregistration.ParamKind), b.(*admissionregistrationv1beta1.ParamKind), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ParamRef)(nil), (*admissionregistration.ParamRef)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ParamRef_To_admissionregistration_ParamRef(a.(*admissionregistrationv1beta1.ParamRef), b.(*admissionregistration.ParamRef), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ParamRef)(nil), (*admissionregistrationv1beta1.ParamRef)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ParamRef_To_v1beta1_ParamRef(a.(*admissionregistration.ParamRef), b.(*admissionregistrationv1beta1.ParamRef), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ServiceReference)(nil), (*admissionregistration.ServiceReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ServiceReference_To_admissionregistration_ServiceReference(a.(*admissionregistrationv1beta1.ServiceReference), b.(*admissionregistration.ServiceReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ServiceReference)(nil), (*admissionregistrationv1beta1.ServiceReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ServiceReference_To_v1beta1_ServiceReference(a.(*admissionregistration.ServiceReference), b.(*admissionregistrationv1beta1.ServiceReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.TypeChecking)(nil), (*admissionregistration.TypeChecking)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_TypeChecking_To_admissionregistration_TypeChecking(a.(*admissionregistrationv1beta1.TypeChecking), b.(*admissionregistration.TypeChecking), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.TypeChecking)(nil), (*admissionregistrationv1beta1.TypeChecking)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_TypeChecking_To_v1beta1_TypeChecking(a.(*admissionregistration.TypeChecking), b.(*admissionregistrationv1beta1.TypeChecking), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingAdmissionPolicy)(nil), (*admissionregistration.ValidatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(a.(*admissionregistrationv1beta1.ValidatingAdmissionPolicy), b.(*admissionregistration.ValidatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicy)(nil), (*admissionregistrationv1beta1.ValidatingAdmissionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1beta1_ValidatingAdmissionPolicy(a.(*admissionregistration.ValidatingAdmissionPolicy), b.(*admissionregistrationv1beta1.ValidatingAdmissionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding)(nil), (*admissionregistration.ValidatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(a.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding), b.(*admissionregistration.ValidatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBinding)(nil), (*admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1beta1_ValidatingAdmissionPolicyBinding(a.(*admissionregistration.ValidatingAdmissionPolicyBinding), b.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList)(nil), (*admissionregistration.ValidatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(a.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList), b.(*admissionregistration.ValidatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBindingList)(nil), (*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1beta1_ValidatingAdmissionPolicyBindingList(a.(*admissionregistration.ValidatingAdmissionPolicyBindingList), b.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingSpec)(nil), (*admissionregistration.ValidatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(a.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingSpec), b.(*admissionregistration.ValidatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyBindingSpec)(nil), (*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1beta1_ValidatingAdmissionPolicyBindingSpec(a.(*admissionregistration.ValidatingAdmissionPolicyBindingSpec), b.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingAdmissionPolicyList)(nil), (*admissionregistration.ValidatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(a.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyList), b.(*admissionregistration.ValidatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyList)(nil), (*admissionregistrationv1beta1.ValidatingAdmissionPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1beta1_ValidatingAdmissionPolicyList(a.(*admissionregistration.ValidatingAdmissionPolicyList), b.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingAdmissionPolicySpec)(nil), (*admissionregistration.ValidatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(a.(*admissionregistrationv1beta1.ValidatingAdmissionPolicySpec), b.(*admissionregistration.ValidatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicySpec)(nil), (*admissionregistrationv1beta1.ValidatingAdmissionPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1beta1_ValidatingAdmissionPolicySpec(a.(*admissionregistration.ValidatingAdmissionPolicySpec), b.(*admissionregistrationv1beta1.ValidatingAdmissionPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingAdmissionPolicyStatus)(nil), (*admissionregistration.ValidatingAdmissionPolicyStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(a.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyStatus), b.(*admissionregistration.ValidatingAdmissionPolicyStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingAdmissionPolicyStatus)(nil), (*admissionregistrationv1beta1.ValidatingAdmissionPolicyStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1beta1_ValidatingAdmissionPolicyStatus(a.(*admissionregistration.ValidatingAdmissionPolicyStatus), b.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingWebhook)(nil), (*admissionregistration.ValidatingWebhook)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(a.(*admissionregistrationv1beta1.ValidatingWebhook), b.(*admissionregistration.ValidatingWebhook), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingWebhook)(nil), (*admissionregistrationv1beta1.ValidatingWebhook)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingWebhook_To_v1beta1_ValidatingWebhook(a.(*admissionregistration.ValidatingWebhook), b.(*admissionregistrationv1beta1.ValidatingWebhook), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingWebhookConfiguration)(nil), (*admissionregistration.ValidatingWebhookConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(a.(*admissionregistrationv1beta1.ValidatingWebhookConfiguration), b.(*admissionregistration.ValidatingWebhookConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingWebhookConfiguration)(nil), (*admissionregistrationv1beta1.ValidatingWebhookConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingWebhookConfiguration_To_v1beta1_ValidatingWebhookConfiguration(a.(*admissionregistration.ValidatingWebhookConfiguration), b.(*admissionregistrationv1beta1.ValidatingWebhookConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.ValidatingWebhookConfigurationList)(nil), (*admissionregistration.ValidatingWebhookConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList(a.(*admissionregistrationv1beta1.ValidatingWebhookConfigurationList), b.(*admissionregistration.ValidatingWebhookConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.ValidatingWebhookConfigurationList)(nil), (*admissionregistrationv1beta1.ValidatingWebhookConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_ValidatingWebhookConfigurationList_To_v1beta1_ValidatingWebhookConfigurationList(a.(*admissionregistration.ValidatingWebhookConfigurationList), b.(*admissionregistrationv1beta1.ValidatingWebhookConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.Validation)(nil), (*admissionregistration.Validation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Validation_To_admissionregistration_Validation(a.(*admissionregistrationv1beta1.Validation), b.(*admissionregistration.Validation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Validation)(nil), (*admissionregistrationv1beta1.Validation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Validation_To_v1beta1_Validation(a.(*admissionregistration.Validation), b.(*admissionregistrationv1beta1.Validation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.Variable)(nil), (*admissionregistration.Variable)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Variable_To_admissionregistration_Variable(a.(*admissionregistrationv1beta1.Variable), b.(*admissionregistration.Variable), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.Variable)(nil), (*admissionregistrationv1beta1.Variable)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_Variable_To_v1beta1_Variable(a.(*admissionregistration.Variable), b.(*admissionregistrationv1beta1.Variable), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistrationv1beta1.WebhookClientConfig)(nil), (*admissionregistration.WebhookClientConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(a.(*admissionregistrationv1beta1.WebhookClientConfig), b.(*admissionregistration.WebhookClientConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*admissionregistration.WebhookClientConfig)(nil), (*admissionregistrationv1beta1.WebhookClientConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_admissionregistration_WebhookClientConfig_To_v1beta1_WebhookClientConfig(a.(*admissionregistration.WebhookClientConfig), b.(*admissionregistrationv1beta1.WebhookClientConfig), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration(in *admissionregistrationv1beta1.ApplyConfiguration, out *admissionregistration.ApplyConfiguration, s conversion.Scope) error {
        out.Expression = in.Expression
        return nil
}

// Convert_v1beta1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration is an autogenerated conversion function.
func Convert_v1beta1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration(in *admissionregistrationv1beta1.ApplyConfiguration, out *admissionregistration.ApplyConfiguration, s conversion.Scope) error {
        return autoConvert_v1beta1_ApplyConfiguration_To_admissionregistration_ApplyConfiguration(in, out, s)
}

func autoConvert_admissionregistration_ApplyConfiguration_To_v1beta1_ApplyConfiguration(in *admissionregistration.ApplyConfiguration, out *admissionregistrationv1beta1.ApplyConfiguration, s conversion.Scope) error {
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_ApplyConfiguration_To_v1beta1_ApplyConfiguration is an autogenerated conversion function.
func Convert_admissionregistration_ApplyConfiguration_To_v1beta1_ApplyConfiguration(in *admissionregistration.ApplyConfiguration, out *admissionregistrationv1beta1.ApplyConfiguration, s conversion.Scope) error {
        return autoConvert_admissionregistration_ApplyConfiguration_To_v1beta1_ApplyConfiguration(in, out, s)
}

func autoConvert_v1beta1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in *admissionregistrationv1beta1.AuditAnnotation, out *admissionregistration.AuditAnnotation, s conversion.Scope) error {
        out.Key = in.Key
        out.ValueExpression = in.ValueExpression
        return nil
}

// Convert_v1beta1_AuditAnnotation_To_admissionregistration_AuditAnnotation is an autogenerated conversion function.
func Convert_v1beta1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in *admissionregistrationv1beta1.AuditAnnotation, out *admissionregistration.AuditAnnotation, s conversion.Scope) error {
        return autoConvert_v1beta1_AuditAnnotation_To_admissionregistration_AuditAnnotation(in, out, s)
}

func autoConvert_admissionregistration_AuditAnnotation_To_v1beta1_AuditAnnotation(in *admissionregistration.AuditAnnotation, out *admissionregistrationv1beta1.AuditAnnotation, s conversion.Scope) error {
        out.Key = in.Key
        out.ValueExpression = in.ValueExpression
        return nil
}

// Convert_admissionregistration_AuditAnnotation_To_v1beta1_AuditAnnotation is an autogenerated conversion function.
func Convert_admissionregistration_AuditAnnotation_To_v1beta1_AuditAnnotation(in *admissionregistration.AuditAnnotation, out *admissionregistrationv1beta1.AuditAnnotation, s conversion.Scope) error {
        return autoConvert_admissionregistration_AuditAnnotation_To_v1beta1_AuditAnnotation(in, out, s)
}

func autoConvert_v1beta1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in *admissionregistrationv1beta1.ExpressionWarning, out *admissionregistration.ExpressionWarning, s conversion.Scope) error {
        out.FieldRef = in.FieldRef
        out.Warning = in.Warning
        return nil
}

// Convert_v1beta1_ExpressionWarning_To_admissionregistration_ExpressionWarning is an autogenerated conversion function.
func Convert_v1beta1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in *admissionregistrationv1beta1.ExpressionWarning, out *admissionregistration.ExpressionWarning, s conversion.Scope) error {
        return autoConvert_v1beta1_ExpressionWarning_To_admissionregistration_ExpressionWarning(in, out, s)
}

func autoConvert_admissionregistration_ExpressionWarning_To_v1beta1_ExpressionWarning(in *admissionregistration.ExpressionWarning, out *admissionregistrationv1beta1.ExpressionWarning, s conversion.Scope) error {
        out.FieldRef = in.FieldRef
        out.Warning = in.Warning
        return nil
}

// Convert_admissionregistration_ExpressionWarning_To_v1beta1_ExpressionWarning is an autogenerated conversion function.
func Convert_admissionregistration_ExpressionWarning_To_v1beta1_ExpressionWarning(in *admissionregistration.ExpressionWarning, out *admissionregistrationv1beta1.ExpressionWarning, s conversion.Scope) error {
        return autoConvert_admissionregistration_ExpressionWarning_To_v1beta1_ExpressionWarning(in, out, s)
}

func autoConvert_v1beta1_JSONPatch_To_admissionregistration_JSONPatch(in *admissionregistrationv1beta1.JSONPatch, out *admissionregistration.JSONPatch, s conversion.Scope) error {
        out.Expression = in.Expression
        return nil
}

// Convert_v1beta1_JSONPatch_To_admissionregistration_JSONPatch is an autogenerated conversion function.
func Convert_v1beta1_JSONPatch_To_admissionregistration_JSONPatch(in *admissionregistrationv1beta1.JSONPatch, out *admissionregistration.JSONPatch, s conversion.Scope) error {
        return autoConvert_v1beta1_JSONPatch_To_admissionregistration_JSONPatch(in, out, s)
}

func autoConvert_admissionregistration_JSONPatch_To_v1beta1_JSONPatch(in *admissionregistration.JSONPatch, out *admissionregistrationv1beta1.JSONPatch, s conversion.Scope) error {
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_JSONPatch_To_v1beta1_JSONPatch is an autogenerated conversion function.
func Convert_admissionregistration_JSONPatch_To_v1beta1_JSONPatch(in *admissionregistration.JSONPatch, out *admissionregistrationv1beta1.JSONPatch, s conversion.Scope) error {
        return autoConvert_admissionregistration_JSONPatch_To_v1beta1_JSONPatch(in, out, s)
}

func autoConvert_v1beta1_MatchCondition_To_admissionregistration_MatchCondition(in *admissionregistrationv1beta1.MatchCondition, out *admissionregistration.MatchCondition, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_v1beta1_MatchCondition_To_admissionregistration_MatchCondition is an autogenerated conversion function.
func Convert_v1beta1_MatchCondition_To_admissionregistration_MatchCondition(in *admissionregistrationv1beta1.MatchCondition, out *admissionregistration.MatchCondition, s conversion.Scope) error {
        return autoConvert_v1beta1_MatchCondition_To_admissionregistration_MatchCondition(in, out, s)
}

func autoConvert_admissionregistration_MatchCondition_To_v1beta1_MatchCondition(in *admissionregistration.MatchCondition, out *admissionregistrationv1beta1.MatchCondition, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_MatchCondition_To_v1beta1_MatchCondition is an autogenerated conversion function.
func Convert_admissionregistration_MatchCondition_To_v1beta1_MatchCondition(in *admissionregistration.MatchCondition, out *admissionregistrationv1beta1.MatchCondition, s conversion.Scope) error {
        return autoConvert_admissionregistration_MatchCondition_To_v1beta1_MatchCondition(in, out, s)
}

func autoConvert_v1beta1_MatchResources_To_admissionregistration_MatchResources(in *admissionregistrationv1beta1.MatchResources, out *admissionregistration.MatchResources, s conversion.Scope) error {
        out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        if in.ResourceRules != nil {
                in, out := &in.ResourceRules, &out.ResourceRules
                *out = make([]admissionregistration.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ResourceRules = nil
        }
        if in.ExcludeResourceRules != nil {
                in, out := &in.ExcludeResourceRules, &out.ExcludeResourceRules
                *out = make([]admissionregistration.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ExcludeResourceRules = nil
        }
        out.MatchPolicy = (*admissionregistration.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        return nil
}

// Convert_v1beta1_MatchResources_To_admissionregistration_MatchResources is an autogenerated conversion function.
func Convert_v1beta1_MatchResources_To_admissionregistration_MatchResources(in *admissionregistrationv1beta1.MatchResources, out *admissionregistration.MatchResources, s conversion.Scope) error {
        return autoConvert_v1beta1_MatchResources_To_admissionregistration_MatchResources(in, out, s)
}

func autoConvert_admissionregistration_MatchResources_To_v1beta1_MatchResources(in *admissionregistration.MatchResources, out *admissionregistrationv1beta1.MatchResources, s conversion.Scope) error {
        out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        if in.ResourceRules != nil {
                in, out := &in.ResourceRules, &out.ResourceRules
                *out = make([]admissionregistrationv1beta1.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_NamedRuleWithOperations_To_v1beta1_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ResourceRules = nil
        }
        if in.ExcludeResourceRules != nil {
                in, out := &in.ExcludeResourceRules, &out.ExcludeResourceRules
                *out = make([]admissionregistrationv1beta1.NamedRuleWithOperations, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_NamedRuleWithOperations_To_v1beta1_NamedRuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.ExcludeResourceRules = nil
        }
        out.MatchPolicy = (*admissionregistrationv1beta1.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        return nil
}

// Convert_admissionregistration_MatchResources_To_v1beta1_MatchResources is an autogenerated conversion function.
func Convert_admissionregistration_MatchResources_To_v1beta1_MatchResources(in *admissionregistration.MatchResources, out *admissionregistrationv1beta1.MatchResources, s conversion.Scope) error {
        return autoConvert_admissionregistration_MatchResources_To_v1beta1_MatchResources(in, out, s)
}

func autoConvert_v1beta1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(in *admissionregistrationv1beta1.MutatingAdmissionPolicy, out *admissionregistration.MutatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy is an autogenerated conversion function.
func Convert_v1beta1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(in *admissionregistrationv1beta1.MutatingAdmissionPolicy, out *admissionregistration.MutatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicy_To_v1beta1_MutatingAdmissionPolicy(in *admissionregistration.MutatingAdmissionPolicy, out *admissionregistrationv1beta1.MutatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_MutatingAdmissionPolicySpec_To_v1beta1_MutatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicy_To_v1beta1_MutatingAdmissionPolicy is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicy_To_v1beta1_MutatingAdmissionPolicy(in *admissionregistration.MutatingAdmissionPolicy, out *admissionregistrationv1beta1.MutatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicy_To_v1beta1_MutatingAdmissionPolicy(in, out, s)
}

func autoConvert_v1beta1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(in *admissionregistrationv1beta1.MutatingAdmissionPolicyBinding, out *admissionregistration.MutatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_v1beta1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(in *admissionregistrationv1beta1.MutatingAdmissionPolicyBinding, out *admissionregistration.MutatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1beta1_MutatingAdmissionPolicyBinding(in *admissionregistration.MutatingAdmissionPolicyBinding, out *admissionregistrationv1beta1.MutatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1beta1_MutatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1beta1_MutatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1beta1_MutatingAdmissionPolicyBinding(in *admissionregistration.MutatingAdmissionPolicyBinding, out *admissionregistrationv1beta1.MutatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1beta1_MutatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_v1beta1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList(in *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList, out *admissionregistration.MutatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.MutatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_MutatingAdmissionPolicyBinding_To_admissionregistration_MutatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_v1beta1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList(in *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList, out *admissionregistration.MutatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingAdmissionPolicyBindingList_To_admissionregistration_MutatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1beta1_MutatingAdmissionPolicyBindingList(in *admissionregistration.MutatingAdmissionPolicyBindingList, out *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1beta1.MutatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_MutatingAdmissionPolicyBinding_To_v1beta1_MutatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1beta1_MutatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1beta1_MutatingAdmissionPolicyBindingList(in *admissionregistration.MutatingAdmissionPolicyBindingList, out *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicyBindingList_To_v1beta1_MutatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_v1beta1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(in *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingSpec, out *admissionregistration.MutatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistration.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1beta1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        return nil
}

// Convert_v1beta1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_v1beta1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(in *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingSpec, out *admissionregistration.MutatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingAdmissionPolicyBindingSpec_To_admissionregistration_MutatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1beta1_MutatingAdmissionPolicyBindingSpec(in *admissionregistration.MutatingAdmissionPolicyBindingSpec, out *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistrationv1beta1.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistrationv1beta1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1beta1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1beta1_MutatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1beta1_MutatingAdmissionPolicyBindingSpec(in *admissionregistration.MutatingAdmissionPolicyBindingSpec, out *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicyBindingSpec_To_v1beta1_MutatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_v1beta1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList(in *admissionregistrationv1beta1.MutatingAdmissionPolicyList, out *admissionregistration.MutatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.MutatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_MutatingAdmissionPolicy_To_admissionregistration_MutatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_v1beta1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList(in *admissionregistrationv1beta1.MutatingAdmissionPolicyList, out *admissionregistration.MutatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingAdmissionPolicyList_To_admissionregistration_MutatingAdmissionPolicyList(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicyList_To_v1beta1_MutatingAdmissionPolicyList(in *admissionregistration.MutatingAdmissionPolicyList, out *admissionregistrationv1beta1.MutatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1beta1.MutatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_MutatingAdmissionPolicy_To_v1beta1_MutatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicyList_To_v1beta1_MutatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicyList_To_v1beta1_MutatingAdmissionPolicyList(in *admissionregistration.MutatingAdmissionPolicyList, out *admissionregistrationv1beta1.MutatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicyList_To_v1beta1_MutatingAdmissionPolicyList(in, out, s)
}

func autoConvert_v1beta1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(in *admissionregistrationv1beta1.MutatingAdmissionPolicySpec, out *admissionregistration.MutatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistration.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1beta1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Variables = *(*[]admissionregistration.Variable)(unsafe.Pointer(&in.Variables))
        out.Mutations = *(*[]admissionregistration.Mutation)(unsafe.Pointer(&in.Mutations))
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.ReinvocationPolicy = admissionregistration.ReinvocationPolicyType(in.ReinvocationPolicy)
        return nil
}

// Convert_v1beta1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_v1beta1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(in *admissionregistrationv1beta1.MutatingAdmissionPolicySpec, out *admissionregistration.MutatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingAdmissionPolicySpec_To_admissionregistration_MutatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_admissionregistration_MutatingAdmissionPolicySpec_To_v1beta1_MutatingAdmissionPolicySpec(in *admissionregistration.MutatingAdmissionPolicySpec, out *admissionregistrationv1beta1.MutatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistrationv1beta1.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistrationv1beta1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1beta1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Variables = *(*[]admissionregistrationv1beta1.Variable)(unsafe.Pointer(&in.Variables))
        out.Mutations = *(*[]admissionregistrationv1beta1.Mutation)(unsafe.Pointer(&in.Mutations))
        out.FailurePolicy = (*admissionregistrationv1beta1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchConditions = *(*[]admissionregistrationv1beta1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.ReinvocationPolicy = admissionregistrationv1.ReinvocationPolicyType(in.ReinvocationPolicy)
        return nil
}

// Convert_admissionregistration_MutatingAdmissionPolicySpec_To_v1beta1_MutatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_admissionregistration_MutatingAdmissionPolicySpec_To_v1beta1_MutatingAdmissionPolicySpec(in *admissionregistration.MutatingAdmissionPolicySpec, out *admissionregistrationv1beta1.MutatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingAdmissionPolicySpec_To_v1beta1_MutatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_v1beta1_MutatingWebhook_To_admissionregistration_MutatingWebhook(in *admissionregistrationv1beta1.MutatingWebhook, out *admissionregistration.MutatingWebhook, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_v1beta1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(&in.ClientConfig, &out.ClientConfig, s); err != nil {
                return err
        }
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]admissionregistration.RuleWithOperations, len(*in))
                for i := range *in {
                        if err := apisadmissionregistrationv1.Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchPolicy = (*admissionregistration.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        out.SideEffects = (*admissionregistration.SideEffectClass)(unsafe.Pointer(in.SideEffects))
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        out.AdmissionReviewVersions = *(*[]string)(unsafe.Pointer(&in.AdmissionReviewVersions))
        out.ReinvocationPolicy = (*admissionregistration.ReinvocationPolicyType)(unsafe.Pointer(in.ReinvocationPolicy))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        return nil
}

// Convert_v1beta1_MutatingWebhook_To_admissionregistration_MutatingWebhook is an autogenerated conversion function.
func Convert_v1beta1_MutatingWebhook_To_admissionregistration_MutatingWebhook(in *admissionregistrationv1beta1.MutatingWebhook, out *admissionregistration.MutatingWebhook, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingWebhook_To_admissionregistration_MutatingWebhook(in, out, s)
}

func autoConvert_admissionregistration_MutatingWebhook_To_v1beta1_MutatingWebhook(in *admissionregistration.MutatingWebhook, out *admissionregistrationv1beta1.MutatingWebhook, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_admissionregistration_WebhookClientConfig_To_v1beta1_WebhookClientConfig(&in.ClientConfig, &out.ClientConfig, s); err != nil {
                return err
        }
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]admissionregistrationv1.RuleWithOperations, len(*in))
                for i := range *in {
                        if err := apisadmissionregistrationv1.Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        out.FailurePolicy = (*admissionregistrationv1beta1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchPolicy = (*admissionregistrationv1beta1.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        out.SideEffects = (*admissionregistrationv1beta1.SideEffectClass)(unsafe.Pointer(in.SideEffects))
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        out.AdmissionReviewVersions = *(*[]string)(unsafe.Pointer(&in.AdmissionReviewVersions))
        out.ReinvocationPolicy = (*admissionregistrationv1.ReinvocationPolicyType)(unsafe.Pointer(in.ReinvocationPolicy))
        out.MatchConditions = *(*[]admissionregistrationv1beta1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        return nil
}

// Convert_admissionregistration_MutatingWebhook_To_v1beta1_MutatingWebhook is an autogenerated conversion function.
func Convert_admissionregistration_MutatingWebhook_To_v1beta1_MutatingWebhook(in *admissionregistration.MutatingWebhook, out *admissionregistrationv1beta1.MutatingWebhook, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingWebhook_To_v1beta1_MutatingWebhook(in, out, s)
}

func autoConvert_v1beta1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(in *admissionregistrationv1beta1.MutatingWebhookConfiguration, out *admissionregistration.MutatingWebhookConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]admissionregistration.MutatingWebhook, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_MutatingWebhook_To_admissionregistration_MutatingWebhook(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Webhooks = nil
        }
        return nil
}

// Convert_v1beta1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration is an autogenerated conversion function.
func Convert_v1beta1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(in *admissionregistrationv1beta1.MutatingWebhookConfiguration, out *admissionregistration.MutatingWebhookConfiguration, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(in, out, s)
}

func autoConvert_admissionregistration_MutatingWebhookConfiguration_To_v1beta1_MutatingWebhookConfiguration(in *admissionregistration.MutatingWebhookConfiguration, out *admissionregistrationv1beta1.MutatingWebhookConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]admissionregistrationv1beta1.MutatingWebhook, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_MutatingWebhook_To_v1beta1_MutatingWebhook(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Webhooks = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingWebhookConfiguration_To_v1beta1_MutatingWebhookConfiguration is an autogenerated conversion function.
func Convert_admissionregistration_MutatingWebhookConfiguration_To_v1beta1_MutatingWebhookConfiguration(in *admissionregistration.MutatingWebhookConfiguration, out *admissionregistrationv1beta1.MutatingWebhookConfiguration, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingWebhookConfiguration_To_v1beta1_MutatingWebhookConfiguration(in, out, s)
}

func autoConvert_v1beta1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList(in *admissionregistrationv1beta1.MutatingWebhookConfigurationList, out *admissionregistration.MutatingWebhookConfigurationList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.MutatingWebhookConfiguration, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_MutatingWebhookConfiguration_To_admissionregistration_MutatingWebhookConfiguration(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList is an autogenerated conversion function.
func Convert_v1beta1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList(in *admissionregistrationv1beta1.MutatingWebhookConfigurationList, out *admissionregistration.MutatingWebhookConfigurationList, s conversion.Scope) error {
        return autoConvert_v1beta1_MutatingWebhookConfigurationList_To_admissionregistration_MutatingWebhookConfigurationList(in, out, s)
}

func autoConvert_admissionregistration_MutatingWebhookConfigurationList_To_v1beta1_MutatingWebhookConfigurationList(in *admissionregistration.MutatingWebhookConfigurationList, out *admissionregistrationv1beta1.MutatingWebhookConfigurationList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1beta1.MutatingWebhookConfiguration, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_MutatingWebhookConfiguration_To_v1beta1_MutatingWebhookConfiguration(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_MutatingWebhookConfigurationList_To_v1beta1_MutatingWebhookConfigurationList is an autogenerated conversion function.
func Convert_admissionregistration_MutatingWebhookConfigurationList_To_v1beta1_MutatingWebhookConfigurationList(in *admissionregistration.MutatingWebhookConfigurationList, out *admissionregistrationv1beta1.MutatingWebhookConfigurationList, s conversion.Scope) error {
        return autoConvert_admissionregistration_MutatingWebhookConfigurationList_To_v1beta1_MutatingWebhookConfigurationList(in, out, s)
}

func autoConvert_v1beta1_Mutation_To_admissionregistration_Mutation(in *admissionregistrationv1beta1.Mutation, out *admissionregistration.Mutation, s conversion.Scope) error {
        out.PatchType = admissionregistration.PatchType(in.PatchType)
        out.ApplyConfiguration = (*admissionregistration.ApplyConfiguration)(unsafe.Pointer(in.ApplyConfiguration))
        out.JSONPatch = (*admissionregistration.JSONPatch)(unsafe.Pointer(in.JSONPatch))
        return nil
}

// Convert_v1beta1_Mutation_To_admissionregistration_Mutation is an autogenerated conversion function.
func Convert_v1beta1_Mutation_To_admissionregistration_Mutation(in *admissionregistrationv1beta1.Mutation, out *admissionregistration.Mutation, s conversion.Scope) error {
        return autoConvert_v1beta1_Mutation_To_admissionregistration_Mutation(in, out, s)
}

func autoConvert_admissionregistration_Mutation_To_v1beta1_Mutation(in *admissionregistration.Mutation, out *admissionregistrationv1beta1.Mutation, s conversion.Scope) error {
        out.PatchType = admissionregistrationv1beta1.PatchType(in.PatchType)
        out.ApplyConfiguration = (*admissionregistrationv1beta1.ApplyConfiguration)(unsafe.Pointer(in.ApplyConfiguration))
        out.JSONPatch = (*admissionregistrationv1beta1.JSONPatch)(unsafe.Pointer(in.JSONPatch))
        return nil
}

// Convert_admissionregistration_Mutation_To_v1beta1_Mutation is an autogenerated conversion function.
func Convert_admissionregistration_Mutation_To_v1beta1_Mutation(in *admissionregistration.Mutation, out *admissionregistrationv1beta1.Mutation, s conversion.Scope) error {
        return autoConvert_admissionregistration_Mutation_To_v1beta1_Mutation(in, out, s)
}

func autoConvert_v1beta1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in *admissionregistrationv1beta1.NamedRuleWithOperations, out *admissionregistration.NamedRuleWithOperations, s conversion.Scope) error {
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        if err := apisadmissionregistrationv1.Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(&in.RuleWithOperations, &out.RuleWithOperations, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations is an autogenerated conversion function.
func Convert_v1beta1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in *admissionregistrationv1beta1.NamedRuleWithOperations, out *admissionregistration.NamedRuleWithOperations, s conversion.Scope) error {
        return autoConvert_v1beta1_NamedRuleWithOperations_To_admissionregistration_NamedRuleWithOperations(in, out, s)
}

func autoConvert_admissionregistration_NamedRuleWithOperations_To_v1beta1_NamedRuleWithOperations(in *admissionregistration.NamedRuleWithOperations, out *admissionregistrationv1beta1.NamedRuleWithOperations, s conversion.Scope) error {
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        if err := apisadmissionregistrationv1.Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(&in.RuleWithOperations, &out.RuleWithOperations, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_NamedRuleWithOperations_To_v1beta1_NamedRuleWithOperations is an autogenerated conversion function.
func Convert_admissionregistration_NamedRuleWithOperations_To_v1beta1_NamedRuleWithOperations(in *admissionregistration.NamedRuleWithOperations, out *admissionregistrationv1beta1.NamedRuleWithOperations, s conversion.Scope) error {
        return autoConvert_admissionregistration_NamedRuleWithOperations_To_v1beta1_NamedRuleWithOperations(in, out, s)
}

func autoConvert_v1beta1_ParamKind_To_admissionregistration_ParamKind(in *admissionregistrationv1beta1.ParamKind, out *admissionregistration.ParamKind, s conversion.Scope) error {
        out.APIVersion = in.APIVersion
        out.Kind = in.Kind
        return nil
}

// Convert_v1beta1_ParamKind_To_admissionregistration_ParamKind is an autogenerated conversion function.
func Convert_v1beta1_ParamKind_To_admissionregistration_ParamKind(in *admissionregistrationv1beta1.ParamKind, out *admissionregistration.ParamKind, s conversion.Scope) error {
        return autoConvert_v1beta1_ParamKind_To_admissionregistration_ParamKind(in, out, s)
}

func autoConvert_admissionregistration_ParamKind_To_v1beta1_ParamKind(in *admissionregistration.ParamKind, out *admissionregistrationv1beta1.ParamKind, s conversion.Scope) error {
        out.APIVersion = in.APIVersion
        out.Kind = in.Kind
        return nil
}

// Convert_admissionregistration_ParamKind_To_v1beta1_ParamKind is an autogenerated conversion function.
func Convert_admissionregistration_ParamKind_To_v1beta1_ParamKind(in *admissionregistration.ParamKind, out *admissionregistrationv1beta1.ParamKind, s conversion.Scope) error {
        return autoConvert_admissionregistration_ParamKind_To_v1beta1_ParamKind(in, out, s)
}

func autoConvert_v1beta1_ParamRef_To_admissionregistration_ParamRef(in *admissionregistrationv1beta1.ParamRef, out *admissionregistration.ParamRef, s conversion.Scope) error {
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Selector = (*v1.LabelSelector)(unsafe.Pointer(in.Selector))
        out.ParameterNotFoundAction = (*admissionregistration.ParameterNotFoundActionType)(unsafe.Pointer(in.ParameterNotFoundAction))
        return nil
}

// Convert_v1beta1_ParamRef_To_admissionregistration_ParamRef is an autogenerated conversion function.
func Convert_v1beta1_ParamRef_To_admissionregistration_ParamRef(in *admissionregistrationv1beta1.ParamRef, out *admissionregistration.ParamRef, s conversion.Scope) error {
        return autoConvert_v1beta1_ParamRef_To_admissionregistration_ParamRef(in, out, s)
}

func autoConvert_admissionregistration_ParamRef_To_v1beta1_ParamRef(in *admissionregistration.ParamRef, out *admissionregistrationv1beta1.ParamRef, s conversion.Scope) error {
        out.Name = in.Name
        out.Namespace = in.Namespace
        out.Selector = (*v1.LabelSelector)(unsafe.Pointer(in.Selector))
        out.ParameterNotFoundAction = (*admissionregistrationv1beta1.ParameterNotFoundActionType)(unsafe.Pointer(in.ParameterNotFoundAction))
        return nil
}

// Convert_admissionregistration_ParamRef_To_v1beta1_ParamRef is an autogenerated conversion function.
func Convert_admissionregistration_ParamRef_To_v1beta1_ParamRef(in *admissionregistration.ParamRef, out *admissionregistrationv1beta1.ParamRef, s conversion.Scope) error {
        return autoConvert_admissionregistration_ParamRef_To_v1beta1_ParamRef(in, out, s)
}

func autoConvert_v1beta1_ServiceReference_To_admissionregistration_ServiceReference(in *admissionregistrationv1beta1.ServiceReference, out *admissionregistration.ServiceReference, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Name = in.Name
        out.Path = (*string)(unsafe.Pointer(in.Path))
        if err := v1.Convert_Pointer_int32_To_int32(&in.Port, &out.Port, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_ServiceReference_To_admissionregistration_ServiceReference is an autogenerated conversion function.
func Convert_v1beta1_ServiceReference_To_admissionregistration_ServiceReference(in *admissionregistrationv1beta1.ServiceReference, out *admissionregistration.ServiceReference, s conversion.Scope) error {
        return autoConvert_v1beta1_ServiceReference_To_admissionregistration_ServiceReference(in, out, s)
}

func autoConvert_admissionregistration_ServiceReference_To_v1beta1_ServiceReference(in *admissionregistration.ServiceReference, out *admissionregistrationv1beta1.ServiceReference, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Name = in.Name
        out.Path = (*string)(unsafe.Pointer(in.Path))
        if err := v1.Convert_int32_To_Pointer_int32(&in.Port, &out.Port, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_ServiceReference_To_v1beta1_ServiceReference is an autogenerated conversion function.
func Convert_admissionregistration_ServiceReference_To_v1beta1_ServiceReference(in *admissionregistration.ServiceReference, out *admissionregistrationv1beta1.ServiceReference, s conversion.Scope) error {
        return autoConvert_admissionregistration_ServiceReference_To_v1beta1_ServiceReference(in, out, s)
}

func autoConvert_v1beta1_TypeChecking_To_admissionregistration_TypeChecking(in *admissionregistrationv1beta1.TypeChecking, out *admissionregistration.TypeChecking, s conversion.Scope) error {
        out.ExpressionWarnings = *(*[]admissionregistration.ExpressionWarning)(unsafe.Pointer(&in.ExpressionWarnings))
        return nil
}

// Convert_v1beta1_TypeChecking_To_admissionregistration_TypeChecking is an autogenerated conversion function.
func Convert_v1beta1_TypeChecking_To_admissionregistration_TypeChecking(in *admissionregistrationv1beta1.TypeChecking, out *admissionregistration.TypeChecking, s conversion.Scope) error {
        return autoConvert_v1beta1_TypeChecking_To_admissionregistration_TypeChecking(in, out, s)
}

func autoConvert_admissionregistration_TypeChecking_To_v1beta1_TypeChecking(in *admissionregistration.TypeChecking, out *admissionregistrationv1beta1.TypeChecking, s conversion.Scope) error {
        out.ExpressionWarnings = *(*[]admissionregistrationv1beta1.ExpressionWarning)(unsafe.Pointer(&in.ExpressionWarnings))
        return nil
}

// Convert_admissionregistration_TypeChecking_To_v1beta1_TypeChecking is an autogenerated conversion function.
func Convert_admissionregistration_TypeChecking_To_v1beta1_TypeChecking(in *admissionregistration.TypeChecking, out *admissionregistrationv1beta1.TypeChecking, s conversion.Scope) error {
        return autoConvert_admissionregistration_TypeChecking_To_v1beta1_TypeChecking(in, out, s)
}

func autoConvert_v1beta1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in *admissionregistrationv1beta1.ValidatingAdmissionPolicy, out *admissionregistration.ValidatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy is an autogenerated conversion function.
func Convert_v1beta1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in *admissionregistrationv1beta1.ValidatingAdmissionPolicy, out *admissionregistration.ValidatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicy_To_v1beta1_ValidatingAdmissionPolicy(in *admissionregistration.ValidatingAdmissionPolicy, out *admissionregistrationv1beta1.ValidatingAdmissionPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1beta1_ValidatingAdmissionPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1beta1_ValidatingAdmissionPolicyStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1beta1_ValidatingAdmissionPolicy is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1beta1_ValidatingAdmissionPolicy(in *admissionregistration.ValidatingAdmissionPolicy, out *admissionregistrationv1beta1.ValidatingAdmissionPolicy, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicy_To_v1beta1_ValidatingAdmissionPolicy(in, out, s)
}

func autoConvert_v1beta1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding, out *admissionregistration.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_v1beta1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding, out *admissionregistration.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1beta1_ValidatingAdmissionPolicyBinding(in *admissionregistration.ValidatingAdmissionPolicyBinding, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1beta1_ValidatingAdmissionPolicyBindingSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1beta1_ValidatingAdmissionPolicyBinding is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1beta1_ValidatingAdmissionPolicyBinding(in *admissionregistration.ValidatingAdmissionPolicyBinding, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1beta1_ValidatingAdmissionPolicyBinding(in, out, s)
}

func autoConvert_v1beta1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList, out *admissionregistration.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.ValidatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_ValidatingAdmissionPolicyBinding_To_admissionregistration_ValidatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_v1beta1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList, out *admissionregistration.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingAdmissionPolicyBindingList_To_admissionregistration_ValidatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1beta1_ValidatingAdmissionPolicyBindingList(in *admissionregistration.ValidatingAdmissionPolicyBindingList, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingAdmissionPolicyBinding_To_v1beta1_ValidatingAdmissionPolicyBinding(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1beta1_ValidatingAdmissionPolicyBindingList is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1beta1_ValidatingAdmissionPolicyBindingList(in *admissionregistration.ValidatingAdmissionPolicyBindingList, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingList_To_v1beta1_ValidatingAdmissionPolicyBindingList(in, out, s)
}

func autoConvert_v1beta1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingSpec, out *admissionregistration.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistration.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1beta1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        out.ValidationActions = *(*[]admissionregistration.ValidationAction)(unsafe.Pointer(&in.ValidationActions))
        return nil
}

// Convert_v1beta1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_v1beta1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingSpec, out *admissionregistration.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingAdmissionPolicyBindingSpec_To_admissionregistration_ValidatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1beta1_ValidatingAdmissionPolicyBindingSpec(in *admissionregistration.ValidatingAdmissionPolicyBindingSpec, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        out.PolicyName = in.PolicyName
        out.ParamRef = (*admissionregistrationv1beta1.ParamRef)(unsafe.Pointer(in.ParamRef))
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(admissionregistrationv1beta1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1beta1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchResources = nil
        }
        out.ValidationActions = *(*[]admissionregistrationv1beta1.ValidationAction)(unsafe.Pointer(&in.ValidationActions))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1beta1_ValidatingAdmissionPolicyBindingSpec is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1beta1_ValidatingAdmissionPolicyBindingSpec(in *admissionregistration.ValidatingAdmissionPolicyBindingSpec, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingSpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyBindingSpec_To_v1beta1_ValidatingAdmissionPolicyBindingSpec(in, out, s)
}

func autoConvert_v1beta1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyList, out *admissionregistration.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.ValidatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_ValidatingAdmissionPolicy_To_admissionregistration_ValidatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_v1beta1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyList, out *admissionregistration.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingAdmissionPolicyList_To_admissionregistration_ValidatingAdmissionPolicyList(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyList_To_v1beta1_ValidatingAdmissionPolicyList(in *admissionregistration.ValidatingAdmissionPolicyList, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1beta1.ValidatingAdmissionPolicy, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingAdmissionPolicy_To_v1beta1_ValidatingAdmissionPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1beta1_ValidatingAdmissionPolicyList is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyList_To_v1beta1_ValidatingAdmissionPolicyList(in *admissionregistration.ValidatingAdmissionPolicyList, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyList, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyList_To_v1beta1_ValidatingAdmissionPolicyList(in, out, s)
}

func autoConvert_v1beta1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in *admissionregistrationv1beta1.ValidatingAdmissionPolicySpec, out *admissionregistration.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistration.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistration.MatchResources)
                if err := Convert_v1beta1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Validations = *(*[]admissionregistration.Validation)(unsafe.Pointer(&in.Validations))
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.AuditAnnotations = *(*[]admissionregistration.AuditAnnotation)(unsafe.Pointer(&in.AuditAnnotations))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.Variables = *(*[]admissionregistration.Variable)(unsafe.Pointer(&in.Variables))
        return nil
}

// Convert_v1beta1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_v1beta1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in *admissionregistrationv1beta1.ValidatingAdmissionPolicySpec, out *admissionregistration.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingAdmissionPolicySpec_To_admissionregistration_ValidatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1beta1_ValidatingAdmissionPolicySpec(in *admissionregistration.ValidatingAdmissionPolicySpec, out *admissionregistrationv1beta1.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        out.ParamKind = (*admissionregistrationv1beta1.ParamKind)(unsafe.Pointer(in.ParamKind))
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(admissionregistrationv1beta1.MatchResources)
                if err := Convert_admissionregistration_MatchResources_To_v1beta1_MatchResources(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.MatchConstraints = nil
        }
        out.Validations = *(*[]admissionregistrationv1beta1.Validation)(unsafe.Pointer(&in.Validations))
        out.MatchConditions = *(*[]admissionregistrationv1beta1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        out.FailurePolicy = (*admissionregistrationv1beta1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.AuditAnnotations = *(*[]admissionregistrationv1beta1.AuditAnnotation)(unsafe.Pointer(&in.AuditAnnotations))
        out.Variables = *(*[]admissionregistrationv1beta1.Variable)(unsafe.Pointer(&in.Variables))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1beta1_ValidatingAdmissionPolicySpec is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1beta1_ValidatingAdmissionPolicySpec(in *admissionregistration.ValidatingAdmissionPolicySpec, out *admissionregistrationv1beta1.ValidatingAdmissionPolicySpec, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicySpec_To_v1beta1_ValidatingAdmissionPolicySpec(in, out, s)
}

func autoConvert_v1beta1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyStatus, out *admissionregistration.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.TypeChecking = (*admissionregistration.TypeChecking)(unsafe.Pointer(in.TypeChecking))
        out.Conditions = *(*[]v1.Condition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1beta1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus is an autogenerated conversion function.
func Convert_v1beta1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyStatus, out *admissionregistration.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingAdmissionPolicyStatus_To_admissionregistration_ValidatingAdmissionPolicyStatus(in, out, s)
}

func autoConvert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1beta1_ValidatingAdmissionPolicyStatus(in *admissionregistration.ValidatingAdmissionPolicyStatus, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.TypeChecking = (*admissionregistrationv1beta1.TypeChecking)(unsafe.Pointer(in.TypeChecking))
        out.Conditions = *(*[]v1.Condition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1beta1_ValidatingAdmissionPolicyStatus is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1beta1_ValidatingAdmissionPolicyStatus(in *admissionregistration.ValidatingAdmissionPolicyStatus, out *admissionregistrationv1beta1.ValidatingAdmissionPolicyStatus, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingAdmissionPolicyStatus_To_v1beta1_ValidatingAdmissionPolicyStatus(in, out, s)
}

func autoConvert_v1beta1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(in *admissionregistrationv1beta1.ValidatingWebhook, out *admissionregistration.ValidatingWebhook, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_v1beta1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(&in.ClientConfig, &out.ClientConfig, s); err != nil {
                return err
        }
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]admissionregistration.RuleWithOperations, len(*in))
                for i := range *in {
                        if err := apisadmissionregistrationv1.Convert_v1_RuleWithOperations_To_admissionregistration_RuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        out.FailurePolicy = (*admissionregistration.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchPolicy = (*admissionregistration.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        out.SideEffects = (*admissionregistration.SideEffectClass)(unsafe.Pointer(in.SideEffects))
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        out.AdmissionReviewVersions = *(*[]string)(unsafe.Pointer(&in.AdmissionReviewVersions))
        out.MatchConditions = *(*[]admissionregistration.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        return nil
}

// Convert_v1beta1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook is an autogenerated conversion function.
func Convert_v1beta1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(in *admissionregistrationv1beta1.ValidatingWebhook, out *admissionregistration.ValidatingWebhook, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(in, out, s)
}

func autoConvert_admissionregistration_ValidatingWebhook_To_v1beta1_ValidatingWebhook(in *admissionregistration.ValidatingWebhook, out *admissionregistrationv1beta1.ValidatingWebhook, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_admissionregistration_WebhookClientConfig_To_v1beta1_WebhookClientConfig(&in.ClientConfig, &out.ClientConfig, s); err != nil {
                return err
        }
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]admissionregistrationv1.RuleWithOperations, len(*in))
                for i := range *in {
                        if err := apisadmissionregistrationv1.Convert_admissionregistration_RuleWithOperations_To_v1_RuleWithOperations(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        out.FailurePolicy = (*admissionregistrationv1beta1.FailurePolicyType)(unsafe.Pointer(in.FailurePolicy))
        out.MatchPolicy = (*admissionregistrationv1beta1.MatchPolicyType)(unsafe.Pointer(in.MatchPolicy))
        out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.ObjectSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ObjectSelector))
        out.SideEffects = (*admissionregistrationv1beta1.SideEffectClass)(unsafe.Pointer(in.SideEffects))
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        out.AdmissionReviewVersions = *(*[]string)(unsafe.Pointer(&in.AdmissionReviewVersions))
        out.MatchConditions = *(*[]admissionregistrationv1beta1.MatchCondition)(unsafe.Pointer(&in.MatchConditions))
        return nil
}

// Convert_admissionregistration_ValidatingWebhook_To_v1beta1_ValidatingWebhook is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingWebhook_To_v1beta1_ValidatingWebhook(in *admissionregistration.ValidatingWebhook, out *admissionregistrationv1beta1.ValidatingWebhook, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingWebhook_To_v1beta1_ValidatingWebhook(in, out, s)
}

func autoConvert_v1beta1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(in *admissionregistrationv1beta1.ValidatingWebhookConfiguration, out *admissionregistration.ValidatingWebhookConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]admissionregistration.ValidatingWebhook, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_ValidatingWebhook_To_admissionregistration_ValidatingWebhook(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Webhooks = nil
        }
        return nil
}

// Convert_v1beta1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration is an autogenerated conversion function.
func Convert_v1beta1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(in *admissionregistrationv1beta1.ValidatingWebhookConfiguration, out *admissionregistration.ValidatingWebhookConfiguration, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(in, out, s)
}

func autoConvert_admissionregistration_ValidatingWebhookConfiguration_To_v1beta1_ValidatingWebhookConfiguration(in *admissionregistration.ValidatingWebhookConfiguration, out *admissionregistrationv1beta1.ValidatingWebhookConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]admissionregistrationv1beta1.ValidatingWebhook, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingWebhook_To_v1beta1_ValidatingWebhook(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Webhooks = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingWebhookConfiguration_To_v1beta1_ValidatingWebhookConfiguration is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingWebhookConfiguration_To_v1beta1_ValidatingWebhookConfiguration(in *admissionregistration.ValidatingWebhookConfiguration, out *admissionregistrationv1beta1.ValidatingWebhookConfiguration, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingWebhookConfiguration_To_v1beta1_ValidatingWebhookConfiguration(in, out, s)
}

func autoConvert_v1beta1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList(in *admissionregistrationv1beta1.ValidatingWebhookConfigurationList, out *admissionregistration.ValidatingWebhookConfigurationList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistration.ValidatingWebhookConfiguration, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_ValidatingWebhookConfiguration_To_admissionregistration_ValidatingWebhookConfiguration(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList is an autogenerated conversion function.
func Convert_v1beta1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList(in *admissionregistrationv1beta1.ValidatingWebhookConfigurationList, out *admissionregistration.ValidatingWebhookConfigurationList, s conversion.Scope) error {
        return autoConvert_v1beta1_ValidatingWebhookConfigurationList_To_admissionregistration_ValidatingWebhookConfigurationList(in, out, s)
}

func autoConvert_admissionregistration_ValidatingWebhookConfigurationList_To_v1beta1_ValidatingWebhookConfigurationList(in *admissionregistration.ValidatingWebhookConfigurationList, out *admissionregistrationv1beta1.ValidatingWebhookConfigurationList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]admissionregistrationv1beta1.ValidatingWebhookConfiguration, len(*in))
                for i := range *in {
                        if err := Convert_admissionregistration_ValidatingWebhookConfiguration_To_v1beta1_ValidatingWebhookConfiguration(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_admissionregistration_ValidatingWebhookConfigurationList_To_v1beta1_ValidatingWebhookConfigurationList is an autogenerated conversion function.
func Convert_admissionregistration_ValidatingWebhookConfigurationList_To_v1beta1_ValidatingWebhookConfigurationList(in *admissionregistration.ValidatingWebhookConfigurationList, out *admissionregistrationv1beta1.ValidatingWebhookConfigurationList, s conversion.Scope) error {
        return autoConvert_admissionregistration_ValidatingWebhookConfigurationList_To_v1beta1_ValidatingWebhookConfigurationList(in, out, s)
}

func autoConvert_v1beta1_Validation_To_admissionregistration_Validation(in *admissionregistrationv1beta1.Validation, out *admissionregistration.Validation, s conversion.Scope) error {
        out.Expression = in.Expression
        out.Message = in.Message
        out.Reason = (*v1.StatusReason)(unsafe.Pointer(in.Reason))
        out.MessageExpression = in.MessageExpression
        return nil
}

// Convert_v1beta1_Validation_To_admissionregistration_Validation is an autogenerated conversion function.
func Convert_v1beta1_Validation_To_admissionregistration_Validation(in *admissionregistrationv1beta1.Validation, out *admissionregistration.Validation, s conversion.Scope) error {
        return autoConvert_v1beta1_Validation_To_admissionregistration_Validation(in, out, s)
}

func autoConvert_admissionregistration_Validation_To_v1beta1_Validation(in *admissionregistration.Validation, out *admissionregistrationv1beta1.Validation, s conversion.Scope) error {
        out.Expression = in.Expression
        out.Message = in.Message
        out.Reason = (*v1.StatusReason)(unsafe.Pointer(in.Reason))
        out.MessageExpression = in.MessageExpression
        return nil
}

// Convert_admissionregistration_Validation_To_v1beta1_Validation is an autogenerated conversion function.
func Convert_admissionregistration_Validation_To_v1beta1_Validation(in *admissionregistration.Validation, out *admissionregistrationv1beta1.Validation, s conversion.Scope) error {
        return autoConvert_admissionregistration_Validation_To_v1beta1_Validation(in, out, s)
}

func autoConvert_v1beta1_Variable_To_admissionregistration_Variable(in *admissionregistrationv1beta1.Variable, out *admissionregistration.Variable, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_v1beta1_Variable_To_admissionregistration_Variable is an autogenerated conversion function.
func Convert_v1beta1_Variable_To_admissionregistration_Variable(in *admissionregistrationv1beta1.Variable, out *admissionregistration.Variable, s conversion.Scope) error {
        return autoConvert_v1beta1_Variable_To_admissionregistration_Variable(in, out, s)
}

func autoConvert_admissionregistration_Variable_To_v1beta1_Variable(in *admissionregistration.Variable, out *admissionregistrationv1beta1.Variable, s conversion.Scope) error {
        out.Name = in.Name
        out.Expression = in.Expression
        return nil
}

// Convert_admissionregistration_Variable_To_v1beta1_Variable is an autogenerated conversion function.
func Convert_admissionregistration_Variable_To_v1beta1_Variable(in *admissionregistration.Variable, out *admissionregistrationv1beta1.Variable, s conversion.Scope) error {
        return autoConvert_admissionregistration_Variable_To_v1beta1_Variable(in, out, s)
}

func autoConvert_v1beta1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(in *admissionregistrationv1beta1.WebhookClientConfig, out *admissionregistration.WebhookClientConfig, s conversion.Scope) error {
        out.URL = (*string)(unsafe.Pointer(in.URL))
        if in.Service != nil {
                in, out := &in.Service, &out.Service
                *out = new(admissionregistration.ServiceReference)
                if err := Convert_v1beta1_ServiceReference_To_admissionregistration_ServiceReference(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Service = nil
        }
        out.CABundle = *(*[]byte)(unsafe.Pointer(&in.CABundle))
        return nil
}

// Convert_v1beta1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig is an autogenerated conversion function.
func Convert_v1beta1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(in *admissionregistrationv1beta1.WebhookClientConfig, out *admissionregistration.WebhookClientConfig, s conversion.Scope) error {
        return autoConvert_v1beta1_WebhookClientConfig_To_admissionregistration_WebhookClientConfig(in, out, s)
}

func autoConvert_admissionregistration_WebhookClientConfig_To_v1beta1_WebhookClientConfig(in *admissionregistration.WebhookClientConfig, out *admissionregistrationv1beta1.WebhookClientConfig, s conversion.Scope) error {
        out.URL = (*string)(unsafe.Pointer(in.URL))
        if in.Service != nil {
                in, out := &in.Service, &out.Service
                *out = new(admissionregistrationv1beta1.ServiceReference)
                if err := Convert_admissionregistration_ServiceReference_To_v1beta1_ServiceReference(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Service = nil
        }
        out.CABundle = *(*[]byte)(unsafe.Pointer(&in.CABundle))
        return nil
}

// Convert_admissionregistration_WebhookClientConfig_To_v1beta1_WebhookClientConfig is an autogenerated conversion function.
func Convert_admissionregistration_WebhookClientConfig_To_v1beta1_WebhookClientConfig(in *admissionregistration.WebhookClientConfig, out *admissionregistrationv1beta1.WebhookClientConfig, s conversion.Scope) error {
        return autoConvert_admissionregistration_WebhookClientConfig_To_v1beta1_WebhookClientConfig(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        v1 "k8s.io/kubernetes/pkg/apis/admissionregistration/v1"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.MutatingAdmissionPolicy{}, func(obj interface{}) {
                SetObjectDefaults_MutatingAdmissionPolicy(obj.(*admissionregistrationv1beta1.MutatingAdmissionPolicy))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.MutatingAdmissionPolicyBinding{}, func(obj interface{}) {
                SetObjectDefaults_MutatingAdmissionPolicyBinding(obj.(*admissionregistrationv1beta1.MutatingAdmissionPolicyBinding))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList{}, func(obj interface{}) {
                SetObjectDefaults_MutatingAdmissionPolicyBindingList(obj.(*admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.MutatingAdmissionPolicyList{}, func(obj interface{}) {
                SetObjectDefaults_MutatingAdmissionPolicyList(obj.(*admissionregistrationv1beta1.MutatingAdmissionPolicyList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.MutatingWebhookConfiguration{}, func(obj interface{}) {
                SetObjectDefaults_MutatingWebhookConfiguration(obj.(*admissionregistrationv1beta1.MutatingWebhookConfiguration))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.MutatingWebhookConfigurationList{}, func(obj interface{}) {
                SetObjectDefaults_MutatingWebhookConfigurationList(obj.(*admissionregistrationv1beta1.MutatingWebhookConfigurationList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.ValidatingAdmissionPolicy{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicy(obj.(*admissionregistrationv1beta1.ValidatingAdmissionPolicy))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyBinding(obj.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyBindingList(obj.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.ValidatingAdmissionPolicyList{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingAdmissionPolicyList(obj.(*admissionregistrationv1beta1.ValidatingAdmissionPolicyList))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.ValidatingWebhookConfiguration{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingWebhookConfiguration(obj.(*admissionregistrationv1beta1.ValidatingWebhookConfiguration))
        })
        scheme.AddTypeDefaultingFunc(&admissionregistrationv1beta1.ValidatingWebhookConfigurationList{}, func(obj interface{}) {
                SetObjectDefaults_ValidatingWebhookConfigurationList(obj.(*admissionregistrationv1beta1.ValidatingWebhookConfigurationList))
        })
        return nil
}

func SetObjectDefaults_MutatingAdmissionPolicy(in *admissionregistrationv1beta1.MutatingAdmissionPolicy) {
        SetDefaults_MutatingAdmissionPolicySpec(&in.Spec)
        if in.Spec.MatchConstraints != nil {
                SetDefaults_MatchResources(in.Spec.MatchConstraints)
                for i := range in.Spec.MatchConstraints.ResourceRules {
                        a := &in.Spec.MatchConstraints.ResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchConstraints.ExcludeResourceRules {
                        a := &in.Spec.MatchConstraints.ExcludeResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_MutatingAdmissionPolicyBinding(in *admissionregistrationv1beta1.MutatingAdmissionPolicyBinding) {
        if in.Spec.MatchResources != nil {
                SetDefaults_MatchResources(in.Spec.MatchResources)
                for i := range in.Spec.MatchResources.ResourceRules {
                        a := &in.Spec.MatchResources.ResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchResources.ExcludeResourceRules {
                        a := &in.Spec.MatchResources.ExcludeResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_MutatingAdmissionPolicyBindingList(in *admissionregistrationv1beta1.MutatingAdmissionPolicyBindingList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_MutatingAdmissionPolicyBinding(a)
        }
}

func SetObjectDefaults_MutatingAdmissionPolicyList(in *admissionregistrationv1beta1.MutatingAdmissionPolicyList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_MutatingAdmissionPolicy(a)
        }
}

func SetObjectDefaults_MutatingWebhookConfiguration(in *admissionregistrationv1beta1.MutatingWebhookConfiguration) {
        for i := range in.Webhooks {
                a := &in.Webhooks[i]
                SetDefaults_MutatingWebhook(a)
                if a.ClientConfig.Service != nil {
                        SetDefaults_ServiceReference(a.ClientConfig.Service)
                }
                for j := range a.Rules {
                        b := &a.Rules[j]
                        v1.SetDefaults_Rule(&b.Rule)
                }
        }
}

func SetObjectDefaults_MutatingWebhookConfigurationList(in *admissionregistrationv1beta1.MutatingWebhookConfigurationList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_MutatingWebhookConfiguration(a)
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicy(in *admissionregistrationv1beta1.ValidatingAdmissionPolicy) {
        SetDefaults_ValidatingAdmissionPolicySpec(&in.Spec)
        if in.Spec.MatchConstraints != nil {
                SetDefaults_MatchResources(in.Spec.MatchConstraints)
                for i := range in.Spec.MatchConstraints.ResourceRules {
                        a := &in.Spec.MatchConstraints.ResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchConstraints.ExcludeResourceRules {
                        a := &in.Spec.MatchConstraints.ExcludeResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyBinding(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyBinding) {
        if in.Spec.MatchResources != nil {
                SetDefaults_MatchResources(in.Spec.MatchResources)
                for i := range in.Spec.MatchResources.ResourceRules {
                        a := &in.Spec.MatchResources.ResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
                for i := range in.Spec.MatchResources.ExcludeResourceRules {
                        a := &in.Spec.MatchResources.ExcludeResourceRules[i]
                        v1.SetDefaults_Rule(&a.RuleWithOperations.Rule)
                }
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyBindingList(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyBindingList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ValidatingAdmissionPolicyBinding(a)
        }
}

func SetObjectDefaults_ValidatingAdmissionPolicyList(in *admissionregistrationv1beta1.ValidatingAdmissionPolicyList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ValidatingAdmissionPolicy(a)
        }
}

func SetObjectDefaults_ValidatingWebhookConfiguration(in *admissionregistrationv1beta1.ValidatingWebhookConfiguration) {
        for i := range in.Webhooks {
                a := &in.Webhooks[i]
                SetDefaults_ValidatingWebhook(a)
                if a.ClientConfig.Service != nil {
                        SetDefaults_ServiceReference(a.ClientConfig.Service)
                }
                for j := range a.Rules {
                        b := &a.Rules[j]
                        v1.SetDefaults_Rule(&b.Rule)
                }
        }
}

func SetObjectDefaults_ValidatingWebhookConfigurationList(in *admissionregistrationv1beta1.ValidatingWebhookConfigurationList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ValidatingWebhookConfiguration(a)
        }
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package admissionregistration

import (
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ApplyConfiguration) DeepCopyInto(out *ApplyConfiguration) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplyConfiguration.
func (in *ApplyConfiguration) DeepCopy() *ApplyConfiguration {
        if in == nil {
                return nil
        }
        out := new(ApplyConfiguration)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AuditAnnotation) DeepCopyInto(out *AuditAnnotation) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuditAnnotation.
func (in *AuditAnnotation) DeepCopy() *AuditAnnotation {
        if in == nil {
                return nil
        }
        out := new(AuditAnnotation)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ExpressionWarning) DeepCopyInto(out *ExpressionWarning) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExpressionWarning.
func (in *ExpressionWarning) DeepCopy() *ExpressionWarning {
        if in == nil {
                return nil
        }
        out := new(ExpressionWarning)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *JSONPatch) DeepCopyInto(out *JSONPatch) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONPatch.
func (in *JSONPatch) DeepCopy() *JSONPatch {
        if in == nil {
                return nil
        }
        out := new(JSONPatch)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MatchCondition) DeepCopyInto(out *MatchCondition) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MatchCondition.
func (in *MatchCondition) DeepCopy() *MatchCondition {
        if in == nil {
                return nil
        }
        out := new(MatchCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MatchResources) DeepCopyInto(out *MatchResources) {
        *out = *in
        if in.NamespaceSelector != nil {
                in, out := &in.NamespaceSelector, &out.NamespaceSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.ObjectSelector != nil {
                in, out := &in.ObjectSelector, &out.ObjectSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.ResourceRules != nil {
                in, out := &in.ResourceRules, &out.ResourceRules
                *out = make([]NamedRuleWithOperations, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.ExcludeResourceRules != nil {
                in, out := &in.ExcludeResourceRules, &out.ExcludeResourceRules
                *out = make([]NamedRuleWithOperations, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.MatchPolicy != nil {
                in, out := &in.MatchPolicy, &out.MatchPolicy
                *out = new(MatchPolicyType)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MatchResources.
func (in *MatchResources) DeepCopy() *MatchResources {
        if in == nil {
                return nil
        }
        out := new(MatchResources)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingAdmissionPolicy) DeepCopyInto(out *MutatingAdmissionPolicy) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingAdmissionPolicy.
func (in *MutatingAdmissionPolicy) DeepCopy() *MutatingAdmissionPolicy {
        if in == nil {
                return nil
        }
        out := new(MutatingAdmissionPolicy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *MutatingAdmissionPolicy) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingAdmissionPolicyBinding) DeepCopyInto(out *MutatingAdmissionPolicyBinding) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingAdmissionPolicyBinding.
func (in *MutatingAdmissionPolicyBinding) DeepCopy() *MutatingAdmissionPolicyBinding {
        if in == nil {
                return nil
        }
        out := new(MutatingAdmissionPolicyBinding)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *MutatingAdmissionPolicyBinding) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingAdmissionPolicyBindingList) DeepCopyInto(out *MutatingAdmissionPolicyBindingList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]MutatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingAdmissionPolicyBindingList.
func (in *MutatingAdmissionPolicyBindingList) DeepCopy() *MutatingAdmissionPolicyBindingList {
        if in == nil {
                return nil
        }
        out := new(MutatingAdmissionPolicyBindingList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *MutatingAdmissionPolicyBindingList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingAdmissionPolicyBindingSpec) DeepCopyInto(out *MutatingAdmissionPolicyBindingSpec) {
        *out = *in
        if in.ParamRef != nil {
                in, out := &in.ParamRef, &out.ParamRef
                *out = new(ParamRef)
                (*in).DeepCopyInto(*out)
        }
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(MatchResources)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingAdmissionPolicyBindingSpec.
func (in *MutatingAdmissionPolicyBindingSpec) DeepCopy() *MutatingAdmissionPolicyBindingSpec {
        if in == nil {
                return nil
        }
        out := new(MutatingAdmissionPolicyBindingSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingAdmissionPolicyList) DeepCopyInto(out *MutatingAdmissionPolicyList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]MutatingAdmissionPolicy, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingAdmissionPolicyList.
func (in *MutatingAdmissionPolicyList) DeepCopy() *MutatingAdmissionPolicyList {
        if in == nil {
                return nil
        }
        out := new(MutatingAdmissionPolicyList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *MutatingAdmissionPolicyList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingAdmissionPolicySpec) DeepCopyInto(out *MutatingAdmissionPolicySpec) {
        *out = *in
        if in.ParamKind != nil {
                in, out := &in.ParamKind, &out.ParamKind
                *out = new(ParamKind)
                **out = **in
        }
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(MatchResources)
                (*in).DeepCopyInto(*out)
        }
        if in.Variables != nil {
                in, out := &in.Variables, &out.Variables
                *out = make([]Variable, len(*in))
                copy(*out, *in)
        }
        if in.Mutations != nil {
                in, out := &in.Mutations, &out.Mutations
                *out = make([]Mutation, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.FailurePolicy != nil {
                in, out := &in.FailurePolicy, &out.FailurePolicy
                *out = new(FailurePolicyType)
                **out = **in
        }
        if in.MatchConditions != nil {
                in, out := &in.MatchConditions, &out.MatchConditions
                *out = make([]MatchCondition, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingAdmissionPolicySpec.
func (in *MutatingAdmissionPolicySpec) DeepCopy() *MutatingAdmissionPolicySpec {
        if in == nil {
                return nil
        }
        out := new(MutatingAdmissionPolicySpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingWebhook) DeepCopyInto(out *MutatingWebhook) {
        *out = *in
        in.ClientConfig.DeepCopyInto(&out.ClientConfig)
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]RuleWithOperations, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.FailurePolicy != nil {
                in, out := &in.FailurePolicy, &out.FailurePolicy
                *out = new(FailurePolicyType)
                **out = **in
        }
        if in.MatchPolicy != nil {
                in, out := &in.MatchPolicy, &out.MatchPolicy
                *out = new(MatchPolicyType)
                **out = **in
        }
        if in.NamespaceSelector != nil {
                in, out := &in.NamespaceSelector, &out.NamespaceSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.ObjectSelector != nil {
                in, out := &in.ObjectSelector, &out.ObjectSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.SideEffects != nil {
                in, out := &in.SideEffects, &out.SideEffects
                *out = new(SideEffectClass)
                **out = **in
        }
        if in.TimeoutSeconds != nil {
                in, out := &in.TimeoutSeconds, &out.TimeoutSeconds
                *out = new(int32)
                **out = **in
        }
        if in.AdmissionReviewVersions != nil {
                in, out := &in.AdmissionReviewVersions, &out.AdmissionReviewVersions
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.ReinvocationPolicy != nil {
                in, out := &in.ReinvocationPolicy, &out.ReinvocationPolicy
                *out = new(ReinvocationPolicyType)
                **out = **in
        }
        if in.MatchConditions != nil {
                in, out := &in.MatchConditions, &out.MatchConditions
                *out = make([]MatchCondition, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingWebhook.
func (in *MutatingWebhook) DeepCopy() *MutatingWebhook {
        if in == nil {
                return nil
        }
        out := new(MutatingWebhook)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingWebhookConfiguration) DeepCopyInto(out *MutatingWebhookConfiguration) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]MutatingWebhook, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingWebhookConfiguration.
func (in *MutatingWebhookConfiguration) DeepCopy() *MutatingWebhookConfiguration {
        if in == nil {
                return nil
        }
        out := new(MutatingWebhookConfiguration)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *MutatingWebhookConfiguration) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MutatingWebhookConfigurationList) DeepCopyInto(out *MutatingWebhookConfigurationList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]MutatingWebhookConfiguration, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MutatingWebhookConfigurationList.
func (in *MutatingWebhookConfigurationList) DeepCopy() *MutatingWebhookConfigurationList {
        if in == nil {
                return nil
        }
        out := new(MutatingWebhookConfigurationList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *MutatingWebhookConfigurationList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Mutation) DeepCopyInto(out *Mutation) {
        *out = *in
        if in.ApplyConfiguration != nil {
                in, out := &in.ApplyConfiguration, &out.ApplyConfiguration
                *out = new(ApplyConfiguration)
                **out = **in
        }
        if in.JSONPatch != nil {
                in, out := &in.JSONPatch, &out.JSONPatch
                *out = new(JSONPatch)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Mutation.
func (in *Mutation) DeepCopy() *Mutation {
        if in == nil {
                return nil
        }
        out := new(Mutation)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NamedRuleWithOperations) DeepCopyInto(out *NamedRuleWithOperations) {
        *out = *in
        if in.ResourceNames != nil {
                in, out := &in.ResourceNames, &out.ResourceNames
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        in.RuleWithOperations.DeepCopyInto(&out.RuleWithOperations)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamedRuleWithOperations.
func (in *NamedRuleWithOperations) DeepCopy() *NamedRuleWithOperations {
        if in == nil {
                return nil
        }
        out := new(NamedRuleWithOperations)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ParamKind) DeepCopyInto(out *ParamKind) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ParamKind.
func (in *ParamKind) DeepCopy() *ParamKind {
        if in == nil {
                return nil
        }
        out := new(ParamKind)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ParamRef) DeepCopyInto(out *ParamRef) {
        *out = *in
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.ParameterNotFoundAction != nil {
                in, out := &in.ParameterNotFoundAction, &out.ParameterNotFoundAction
                *out = new(ParameterNotFoundActionType)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ParamRef.
func (in *ParamRef) DeepCopy() *ParamRef {
        if in == nil {
                return nil
        }
        out := new(ParamRef)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Rule) DeepCopyInto(out *Rule) {
        *out = *in
        if in.APIGroups != nil {
                in, out := &in.APIGroups, &out.APIGroups
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.APIVersions != nil {
                in, out := &in.APIVersions, &out.APIVersions
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Resources != nil {
                in, out := &in.Resources, &out.Resources
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Scope != nil {
                in, out := &in.Scope, &out.Scope
                *out = new(ScopeType)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Rule.
func (in *Rule) DeepCopy() *Rule {
        if in == nil {
                return nil
        }
        out := new(Rule)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RuleWithOperations) DeepCopyInto(out *RuleWithOperations) {
        *out = *in
        if in.Operations != nil {
                in, out := &in.Operations, &out.Operations
                *out = make([]OperationType, len(*in))
                copy(*out, *in)
        }
        in.Rule.DeepCopyInto(&out.Rule)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RuleWithOperations.
func (in *RuleWithOperations) DeepCopy() *RuleWithOperations {
        if in == nil {
                return nil
        }
        out := new(RuleWithOperations)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServiceReference) DeepCopyInto(out *ServiceReference) {
        *out = *in
        if in.Path != nil {
                in, out := &in.Path, &out.Path
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceReference.
func (in *ServiceReference) DeepCopy() *ServiceReference {
        if in == nil {
                return nil
        }
        out := new(ServiceReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TypeChecking) DeepCopyInto(out *TypeChecking) {
        *out = *in
        if in.ExpressionWarnings != nil {
                in, out := &in.ExpressionWarnings, &out.ExpressionWarnings
                *out = make([]ExpressionWarning, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TypeChecking.
func (in *TypeChecking) DeepCopy() *TypeChecking {
        if in == nil {
                return nil
        }
        out := new(TypeChecking)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingAdmissionPolicy) DeepCopyInto(out *ValidatingAdmissionPolicy) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicy.
func (in *ValidatingAdmissionPolicy) DeepCopy() *ValidatingAdmissionPolicy {
        if in == nil {
                return nil
        }
        out := new(ValidatingAdmissionPolicy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ValidatingAdmissionPolicy) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingAdmissionPolicyBinding) DeepCopyInto(out *ValidatingAdmissionPolicyBinding) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicyBinding.
func (in *ValidatingAdmissionPolicyBinding) DeepCopy() *ValidatingAdmissionPolicyBinding {
        if in == nil {
                return nil
        }
        out := new(ValidatingAdmissionPolicyBinding)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ValidatingAdmissionPolicyBinding) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingAdmissionPolicyBindingList) DeepCopyInto(out *ValidatingAdmissionPolicyBindingList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ValidatingAdmissionPolicyBinding, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicyBindingList.
func (in *ValidatingAdmissionPolicyBindingList) DeepCopy() *ValidatingAdmissionPolicyBindingList {
        if in == nil {
                return nil
        }
        out := new(ValidatingAdmissionPolicyBindingList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ValidatingAdmissionPolicyBindingList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingAdmissionPolicyBindingSpec) DeepCopyInto(out *ValidatingAdmissionPolicyBindingSpec) {
        *out = *in
        if in.ParamRef != nil {
                in, out := &in.ParamRef, &out.ParamRef
                *out = new(ParamRef)
                (*in).DeepCopyInto(*out)
        }
        if in.MatchResources != nil {
                in, out := &in.MatchResources, &out.MatchResources
                *out = new(MatchResources)
                (*in).DeepCopyInto(*out)
        }
        if in.ValidationActions != nil {
                in, out := &in.ValidationActions, &out.ValidationActions
                *out = make([]ValidationAction, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicyBindingSpec.
func (in *ValidatingAdmissionPolicyBindingSpec) DeepCopy() *ValidatingAdmissionPolicyBindingSpec {
        if in == nil {
                return nil
        }
        out := new(ValidatingAdmissionPolicyBindingSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingAdmissionPolicyList) DeepCopyInto(out *ValidatingAdmissionPolicyList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ValidatingAdmissionPolicy, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicyList.
func (in *ValidatingAdmissionPolicyList) DeepCopy() *ValidatingAdmissionPolicyList {
        if in == nil {
                return nil
        }
        out := new(ValidatingAdmissionPolicyList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ValidatingAdmissionPolicyList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingAdmissionPolicySpec) DeepCopyInto(out *ValidatingAdmissionPolicySpec) {
        *out = *in
        if in.ParamKind != nil {
                in, out := &in.ParamKind, &out.ParamKind
                *out = new(ParamKind)
                **out = **in
        }
        if in.MatchConstraints != nil {
                in, out := &in.MatchConstraints, &out.MatchConstraints
                *out = new(MatchResources)
                (*in).DeepCopyInto(*out)
        }
        if in.Validations != nil {
                in, out := &in.Validations, &out.Validations
                *out = make([]Validation, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.MatchConditions != nil {
                in, out := &in.MatchConditions, &out.MatchConditions
                *out = make([]MatchCondition, len(*in))
                copy(*out, *in)
        }
        if in.FailurePolicy != nil {
                in, out := &in.FailurePolicy, &out.FailurePolicy
                *out = new(FailurePolicyType)
                **out = **in
        }
        if in.AuditAnnotations != nil {
                in, out := &in.AuditAnnotations, &out.AuditAnnotations
                *out = make([]AuditAnnotation, len(*in))
                copy(*out, *in)
        }
        if in.Variables != nil {
                in, out := &in.Variables, &out.Variables
                *out = make([]Variable, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicySpec.
func (in *ValidatingAdmissionPolicySpec) DeepCopy() *ValidatingAdmissionPolicySpec {
        if in == nil {
                return nil
        }
        out := new(ValidatingAdmissionPolicySpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingAdmissionPolicyStatus) DeepCopyInto(out *ValidatingAdmissionPolicyStatus) {
        *out = *in
        if in.TypeChecking != nil {
                in, out := &in.TypeChecking, &out.TypeChecking
                *out = new(TypeChecking)
                (*in).DeepCopyInto(*out)
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]v1.Condition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingAdmissionPolicyStatus.
func (in *ValidatingAdmissionPolicyStatus) DeepCopy() *ValidatingAdmissionPolicyStatus {
        if in == nil {
                return nil
        }
        out := new(ValidatingAdmissionPolicyStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingWebhook) DeepCopyInto(out *ValidatingWebhook) {
        *out = *in
        in.ClientConfig.DeepCopyInto(&out.ClientConfig)
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]RuleWithOperations, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.FailurePolicy != nil {
                in, out := &in.FailurePolicy, &out.FailurePolicy
                *out = new(FailurePolicyType)
                **out = **in
        }
        if in.MatchPolicy != nil {
                in, out := &in.MatchPolicy, &out.MatchPolicy
                *out = new(MatchPolicyType)
                **out = **in
        }
        if in.NamespaceSelector != nil {
                in, out := &in.NamespaceSelector, &out.NamespaceSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.ObjectSelector != nil {
                in, out := &in.ObjectSelector, &out.ObjectSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.SideEffects != nil {
                in, out := &in.SideEffects, &out.SideEffects
                *out = new(SideEffectClass)
                **out = **in
        }
        if in.TimeoutSeconds != nil {
                in, out := &in.TimeoutSeconds, &out.TimeoutSeconds
                *out = new(int32)
                **out = **in
        }
        if in.AdmissionReviewVersions != nil {
                in, out := &in.AdmissionReviewVersions, &out.AdmissionReviewVersions
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.MatchConditions != nil {
                in, out := &in.MatchConditions, &out.MatchConditions
                *out = make([]MatchCondition, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingWebhook.
func (in *ValidatingWebhook) DeepCopy() *ValidatingWebhook {
        if in == nil {
                return nil
        }
        out := new(ValidatingWebhook)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingWebhookConfiguration) DeepCopyInto(out *ValidatingWebhookConfiguration) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Webhooks != nil {
                in, out := &in.Webhooks, &out.Webhooks
                *out = make([]ValidatingWebhook, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingWebhookConfiguration.
func (in *ValidatingWebhookConfiguration) DeepCopy() *ValidatingWebhookConfiguration {
        if in == nil {
                return nil
        }
        out := new(ValidatingWebhookConfiguration)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ValidatingWebhookConfiguration) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ValidatingWebhookConfigurationList) DeepCopyInto(out *ValidatingWebhookConfigurationList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ValidatingWebhookConfiguration, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ValidatingWebhookConfigurationList.
func (in *ValidatingWebhookConfigurationList) DeepCopy() *ValidatingWebhookConfigurationList {
        if in == nil {
                return nil
        }
        out := new(ValidatingWebhookConfigurationList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ValidatingWebhookConfigurationList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Validation) DeepCopyInto(out *Validation) {
        *out = *in
        if in.Reason != nil {
                in, out := &in.Reason, &out.Reason
                *out = new(v1.StatusReason)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Validation.
func (in *Validation) DeepCopy() *Validation {
        if in == nil {
                return nil
        }
        out := new(Validation)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Variable) DeepCopyInto(out *Variable) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Variable.
func (in *Variable) DeepCopy() *Variable {
        if in == nil {
                return nil
        }
        out := new(Variable)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *WebhookClientConfig) DeepCopyInto(out *WebhookClientConfig) {
        *out = *in
        if in.URL != nil {
                in, out := &in.URL, &out.URL
                *out = new(string)
                **out = **in
        }
        if in.Service != nil {
                in, out := &in.Service, &out.Service
                *out = new(ServiceReference)
                (*in).DeepCopyInto(*out)
        }
        if in.CABundle != nil {
                in, out := &in.CABundle, &out.CABundle
                *out = make([]byte, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WebhookClientConfig.
func (in *WebhookClientConfig) DeepCopy() *WebhookClientConfig {
        if in == nil {
                return nil
        }
        out := new(WebhookClientConfig)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

package apiserverinternal

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "internal.apiserver.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder is the scheme builder with scheme init functions to run for this API package.
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme is a global function that registers this API group & version to a scheme
        AddToScheme = SchemeBuilder.AddToScheme
)

func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &StorageVersion{},
                &StorageVersionList{},
        )
        return nil
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package validation

import (
        "fmt"
        "strings"

        apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
        "k8s.io/apimachinery/pkg/util/sets"
        utilvalidation "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
        "k8s.io/kubernetes/pkg/apis/apiserverinternal"
        apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
)

// ValidateStorageVersion validate the storage version object.
func ValidateStorageVersion(sv *apiserverinternal.StorageVersion) field.ErrorList {
        var allErrs field.ErrorList
        allErrs = append(allErrs, apivalidation.ValidateObjectMeta(&sv.ObjectMeta, false, ValidateStorageVersionName, field.NewPath("metadata"))...)
        allErrs = append(allErrs, validateStorageVersionStatus(sv.Status, field.NewPath("status"))...)
        return allErrs
}

// ValidateStorageVersionName is a ValidateNameFunc for storage version names
func ValidateStorageVersionName(name string, prefix bool) []string {
        var allErrs []string
        idx := strings.LastIndex(name, ".")
        if idx < 0 {
                allErrs = append(allErrs, "name must be in the form of <group>.<resource>")
        } else {
                for _, msg := range utilvalidation.IsDNS1123Subdomain(name[:idx]) {
                        allErrs = append(allErrs, "the group segment "+msg)
                }
                for _, msg := range utilvalidation.IsDNS1035Label(name[idx+1:]) {
                        allErrs = append(allErrs, "the resource segment "+msg)
                }
        }
        return allErrs
}

// ValidateStorageVersionUpdate tests if an update to a StorageVersion is valid.
func ValidateStorageVersionUpdate(sv, oldSV *apiserverinternal.StorageVersion) field.ErrorList {
        // no error since StorageVersionSpec is an empty spec
        return field.ErrorList{}
}

// ValidateStorageVersionStatusUpdate tests if an update to a StorageVersionStatus is valid.
func ValidateStorageVersionStatusUpdate(sv, oldSV *apiserverinternal.StorageVersion) field.ErrorList {
        var allErrs field.ErrorList
        allErrs = append(allErrs, validateStorageVersionStatus(sv.Status, field.NewPath("status"))...)
        return allErrs
}

func validateStorageVersionStatus(ss apiserverinternal.StorageVersionStatus, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        allAPIServerIDs := sets.New[string]()
        for i, ssv := range ss.StorageVersions {
                if allAPIServerIDs.Has(ssv.APIServerID) {
                        allErrs = append(allErrs, field.Duplicate(fldPath.Child("storageVersions").Index(i).Child("apiServerID"), ssv.APIServerID))
                } else {
                        allAPIServerIDs.Insert(ssv.APIServerID)
                }
                allErrs = append(allErrs, validateServerStorageVersion(ssv, fldPath.Child("storageVersions").Index(i))...)
        }
        if err := validateCommonVersion(ss, fldPath); err != nil {
                allErrs = append(allErrs, err)
        }
        allErrs = append(allErrs, validateStorageVersionCondition(ss.Conditions, fldPath)...)
        return allErrs
}

func validateServerStorageVersion(ssv apiserverinternal.ServerStorageVersion, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, msg := range apimachineryvalidation.NameIsDNSSubdomain(ssv.APIServerID, false) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("apiServerID"), ssv.APIServerID, msg))
        }
        if errs := isValidAPIVersion(ssv.EncodingVersion); len(errs) > 0 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("encodingVersion"), ssv.EncodingVersion, strings.Join(errs, ",")))
        }

        found := false
        for i, dv := range ssv.DecodableVersions {
                if errs := isValidAPIVersion(dv); len(errs) > 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("decodableVersions").Index(i), dv, strings.Join(errs, ",")))
                }
                if dv == ssv.EncodingVersion {
                        found = true
                }
        }
        if !found {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("decodableVersions"), ssv.DecodableVersions, fmt.Sprintf("decodableVersions must include encodingVersion %s", ssv.EncodingVersion)))
        }

        for i, sv := range ssv.ServedVersions {
                if errs := isValidAPIVersion(sv); len(errs) > 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("servedVersions").Index(i), sv, strings.Join(errs, ",")))
                }
                foundDecodableVersion := false
                for _, dv := range ssv.DecodableVersions {
                        if sv == dv {
                                foundDecodableVersion = true
                                break
                        }
                }
                if !foundDecodableVersion {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("servedVersions").Index(i), sv, fmt.Sprintf("individual served version : %s must be included in decodableVersions : %s", sv, ssv.DecodableVersions)))
                }
        }
        return allErrs
}

func commonVersion(ssv []apiserverinternal.ServerStorageVersion) *string {
        if len(ssv) == 0 {
                return nil
        }
        commonVersion := ssv[0].EncodingVersion
        for _, v := range ssv[1:] {
                if v.EncodingVersion != commonVersion {
                        return nil
                }
        }
        return &commonVersion
}

func validateCommonVersion(svs apiserverinternal.StorageVersionStatus, fldPath *field.Path) *field.Error {
        actualCommonVersion := commonVersion(svs.StorageVersions)
        if actualCommonVersion == nil && svs.CommonEncodingVersion == nil {
                return nil
        }
        if actualCommonVersion == nil && svs.CommonEncodingVersion != nil {
                return field.Invalid(fldPath.Child("commonEncodingVersion"), *svs.CommonEncodingVersion, "should be nil if servers do not agree on the same encoding version, or if there is no server reporting the supported versions yet")
        }
        if actualCommonVersion != nil && svs.CommonEncodingVersion == nil {
                return field.Invalid(fldPath.Child("commonEncodingVersion"), svs.CommonEncodingVersion, fmt.Sprintf("the common encoding version is %s", *actualCommonVersion))
        }
        if actualCommonVersion != nil && svs.CommonEncodingVersion != nil && *actualCommonVersion != *svs.CommonEncodingVersion {
                return field.Invalid(fldPath.Child("commonEncodingVersion"), *svs.CommonEncodingVersion, fmt.Sprintf("the actual common encoding version is %s", *actualCommonVersion))
        }
        return nil
}

func validateStorageVersionCondition(conditions []apiserverinternal.StorageVersionCondition, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        // We do not verify that the condition type or the condition status is
        // a predefined one because we might add more type or status later.
        seenType := make(map[apiserverinternal.StorageVersionConditionType]int)
        for i, condition := range conditions {
                if ii, ok := seenType[condition.Type]; ok {
                        allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("type"), string(condition.Type),
                                fmt.Sprintf("the type of the condition is not unique, it also appears in conditions[%d]", ii)))
                }
                seenType[condition.Type] = i
                allErrs = append(allErrs, apivalidation.ValidateQualifiedName(string(condition.Type), fldPath.Index(i).Child("type"))...)
                allErrs = append(allErrs, apivalidation.ValidateQualifiedName(string(condition.Status), fldPath.Index(i).Child("status"))...)
                if condition.Reason == "" {
                        allErrs = append(allErrs, field.Required(fldPath.Index(i).Child("reason"), ""))
                }
                if condition.Message == "" {
                        allErrs = append(allErrs, field.Required(fldPath.Index(i).Child("message"), ""))
                }
        }
        return allErrs
}

const dns1035LabelFmt string = "[a-z]([-a-z0-9]*[a-z0-9])?"
const dns1035LabelErrMsg string = "a DNS-1035 label, which must consist of lower case alphanumeric characters or '-', start with an alphabetic character, and end with an alphanumeric character"

// isValidAPIVersion tests whether the value passed is a valid apiVersion. A
// valid apiVersion contains a version string that matches DNS_LABEL format,
// with an optional group/ prefix, where the group string matches DNS_SUBDOMAIN
// format. If the value is not valid, a list of error strings is returned.
// Otherwise an empty list (or nil) is returned.
func isValidAPIVersion(apiVersion string) []string {
        var errs []string
        parts := strings.Split(apiVersion, "/")
        var version string
        switch len(parts) {
        case 1:
                version = parts[0]
        case 2:
                var group string
                group, version = parts[0], parts[1]
                if len(group) == 0 {
                        errs = append(errs, "group part: "+utilvalidation.EmptyError())
                } else if msgs := utilvalidation.IsDNS1123Subdomain(group); len(msgs) != 0 {
                        errs = append(errs, prefixEach(msgs, "group part: ")...)
                }
        default:
                return append(errs, "an apiVersion is "+utilvalidation.RegexError(dns1035LabelErrMsg, dns1035LabelFmt, "my-name", "abc-123")+
                        " with an optional DNS subdomain prefix and '/' (e.g. 'example.com/MyVersion')")
        }

        if len(version) == 0 {
                errs = append(errs, "version part: "+utilvalidation.EmptyError())
        } else if msgs := utilvalidation.IsDNS1035Label(version); len(msgs) != 0 {
                errs = append(errs, prefixEach(msgs, "version part: ")...)
        }
        return errs
}

func prefixEach(msgs []string, prefix string) []string {
        for i := range msgs {
                msgs[i] = prefix + msgs[i]
        }
        return msgs
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package apiserverinternal

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServerStorageVersion) DeepCopyInto(out *ServerStorageVersion) {
        *out = *in
        if in.DecodableVersions != nil {
                in, out := &in.DecodableVersions, &out.DecodableVersions
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.ServedVersions != nil {
                in, out := &in.ServedVersions, &out.ServedVersions
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServerStorageVersion.
func (in *ServerStorageVersion) DeepCopy() *ServerStorageVersion {
        if in == nil {
                return nil
        }
        out := new(ServerStorageVersion)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StorageVersion) DeepCopyInto(out *StorageVersion) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        out.Spec = in.Spec
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageVersion.
func (in *StorageVersion) DeepCopy() *StorageVersion {
        if in == nil {
                return nil
        }
        out := new(StorageVersion)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *StorageVersion) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StorageVersionCondition) DeepCopyInto(out *StorageVersionCondition) {
        *out = *in
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageVersionCondition.
func (in *StorageVersionCondition) DeepCopy() *StorageVersionCondition {
        if in == nil {
                return nil
        }
        out := new(StorageVersionCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StorageVersionList) DeepCopyInto(out *StorageVersionList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]StorageVersion, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageVersionList.
func (in *StorageVersionList) DeepCopy() *StorageVersionList {
        if in == nil {
                return nil
        }
        out := new(StorageVersionList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *StorageVersionList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StorageVersionSpec) DeepCopyInto(out *StorageVersionSpec) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageVersionSpec.
func (in *StorageVersionSpec) DeepCopy() *StorageVersionSpec {
        if in == nil {
                return nil
        }
        out := new(StorageVersionSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StorageVersionStatus) DeepCopyInto(out *StorageVersionStatus) {
        *out = *in
        if in.StorageVersions != nil {
                in, out := &in.StorageVersions, &out.StorageVersions
                *out = make([]ServerStorageVersion, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.CommonEncodingVersion != nil {
                in, out := &in.CommonEncodingVersion, &out.CommonEncodingVersion
                *out = new(string)
                **out = **in
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]StorageVersionCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageVersionStatus.
func (in *StorageVersionStatus) DeepCopy() *StorageVersionStatus {
        if in == nil {
                return nil
        }
        out := new(StorageVersionStatus)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        "fmt"

        "sigs.k8s.io/randfill"

        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
        "k8s.io/apimachinery/pkg/util/intstr"
        "k8s.io/kubernetes/pkg/apis/apps"
)

// Funcs returns the fuzzer functions for the apps api group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(r *apps.ControllerRevision, c randfill.Continue) {
                        c.FillNoCustom(r)
                        // match the fuzzer default content for runtime.Object
                        r.Data = runtime.RawExtension{Raw: []byte(`{"apiVersion":"unknown.group/unknown","kind":"Something","someKey":"someValue"}`)}
                },
                func(s *apps.StatefulSet, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again

                        // match defaulter
                        if len(s.Spec.PodManagementPolicy) == 0 {
                                s.Spec.PodManagementPolicy = apps.OrderedReadyPodManagement
                        }
                        if len(s.Spec.UpdateStrategy.Type) == 0 {
                                s.Spec.UpdateStrategy.Type = apps.RollingUpdateStatefulSetStrategyType
                        }
                        if s.Spec.PersistentVolumeClaimRetentionPolicy == nil {
                                s.Spec.PersistentVolumeClaimRetentionPolicy = &apps.StatefulSetPersistentVolumeClaimRetentionPolicy{}
                        }
                        if len(s.Spec.PersistentVolumeClaimRetentionPolicy.WhenDeleted) == 0 {
                                s.Spec.PersistentVolumeClaimRetentionPolicy.WhenDeleted = apps.RetainPersistentVolumeClaimRetentionPolicyType
                        }
                        if len(s.Spec.PersistentVolumeClaimRetentionPolicy.WhenScaled) == 0 {
                                s.Spec.PersistentVolumeClaimRetentionPolicy.WhenScaled = apps.RetainPersistentVolumeClaimRetentionPolicyType
                        }
                        if s.Spec.RevisionHistoryLimit == nil {
                                s.Spec.RevisionHistoryLimit = new(int32)
                                *s.Spec.RevisionHistoryLimit = 10
                        }
                        if s.Status.ObservedGeneration == nil {
                                s.Status.ObservedGeneration = new(int64)
                        }
                        if s.Status.CollisionCount == nil {
                                s.Status.CollisionCount = new(int32)
                        }
                        if s.Spec.Selector == nil {
                                s.Spec.Selector = &metav1.LabelSelector{MatchLabels: s.Spec.Template.Labels}
                        }
                        if len(s.Labels) == 0 {
                                s.Labels = s.Spec.Template.Labels
                        }
                },
                func(j *apps.Deployment, c randfill.Continue) {
                        c.FillNoCustom(j)

                        // match defaulting
                        if j.Spec.Selector == nil {
                                j.Spec.Selector = &metav1.LabelSelector{MatchLabels: j.Spec.Template.Labels}
                        }
                        if len(j.Labels) == 0 {
                                j.Labels = j.Spec.Template.Labels
                        }
                },
                func(j *apps.DeploymentSpec, c randfill.Continue) {
                        c.FillNoCustom(j) // fuzz self without calling this function again
                        rhl := int32(c.Rand.Int31())
                        pds := int32(c.Rand.Int31())
                        j.RevisionHistoryLimit = &rhl
                        j.ProgressDeadlineSeconds = &pds
                },
                func(j *apps.DeploymentStrategy, c randfill.Continue) {
                        c.FillNoCustom(j) // fuzz self without calling this function again
                        // Ensure that strategyType is one of valid values.
                        strategyTypes := []apps.DeploymentStrategyType{apps.RecreateDeploymentStrategyType, apps.RollingUpdateDeploymentStrategyType}
                        j.Type = strategyTypes[c.Rand.Intn(len(strategyTypes))]
                        if j.Type != apps.RollingUpdateDeploymentStrategyType {
                                j.RollingUpdate = nil
                        } else {
                                rollingUpdate := apps.RollingUpdateDeployment{}
                                if c.Bool() {
                                        rollingUpdate.MaxUnavailable = intstr.FromInt32(c.Rand.Int31())
                                        rollingUpdate.MaxSurge = intstr.FromInt32(c.Rand.Int31())
                                } else {
                                        rollingUpdate.MaxSurge = intstr.FromString(fmt.Sprintf("%d%%", c.Rand.Int31()))
                                }
                                j.RollingUpdate = &rollingUpdate
                        }
                },
                func(j *apps.DaemonSet, c randfill.Continue) {
                        c.FillNoCustom(j)

                        // match defaulter
                        j.Spec.Template.Generation = 0
                        if len(j.ObjectMeta.Labels) == 0 {
                                j.ObjectMeta.Labels = j.Spec.Template.ObjectMeta.Labels
                        }
                },
                func(j *apps.DaemonSetSpec, c randfill.Continue) {
                        c.FillNoCustom(j) // fuzz self without calling this function again
                        rhl := int32(c.Rand.Int31())
                        j.RevisionHistoryLimit = &rhl
                },
                func(j *apps.DaemonSetUpdateStrategy, c randfill.Continue) {
                        c.FillNoCustom(j) // fuzz self without calling this function again
                        // Ensure that strategyType is one of valid values.
                        strategyTypes := []apps.DaemonSetUpdateStrategyType{apps.RollingUpdateDaemonSetStrategyType, apps.OnDeleteDaemonSetStrategyType}
                        j.Type = strategyTypes[c.Rand.Intn(len(strategyTypes))]
                        if j.Type != apps.RollingUpdateDaemonSetStrategyType {
                                j.RollingUpdate = nil
                        } else {
                                rollingUpdate := apps.RollingUpdateDaemonSet{}
                                if c.Bool() {
                                        if c.Bool() {
                                                rollingUpdate.MaxUnavailable = intstr.FromInt32(c.Rand.Int31())
                                                rollingUpdate.MaxSurge = intstr.FromInt32(c.Rand.Int31())
                                        } else {
                                                rollingUpdate.MaxSurge = intstr.FromString(fmt.Sprintf("%d%%", c.Rand.Int31()))
                                        }
                                }

                                j.RollingUpdate = &rollingUpdate
                        }
                },
                func(j *apps.ReplicaSet, c randfill.Continue) {
                        c.FillNoCustom(j)

                        // match defaulter
                        if j.Spec.Selector == nil {
                                j.Spec.Selector = &metav1.LabelSelector{MatchLabels: j.Spec.Template.Labels}
                        }
                        if len(j.Labels) == 0 {
                                j.Labels = j.Spec.Template.Labels
                        }
                },
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

// Package install installs the apps API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/apps"
        "k8s.io/kubernetes/pkg/apis/apps/v1"
        "k8s.io/kubernetes/pkg/apis/apps/v1beta1"
        "k8s.io/kubernetes/pkg/apis/apps/v1beta2"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(apps.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1beta2.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta2.SchemeGroupVersion, v1beta1.SchemeGroupVersion))
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package apps

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
)

var (
        // SchemeBuilder stores functions to add things to a scheme.
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme applies all stored functions t oa scheme.
        AddToScheme = SchemeBuilder.AddToScheme
)

// GroupName is the group name use in this package
const GroupName = "apps"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        // TODO this will get cleaned up with the scheme types are fixed
        scheme.AddKnownTypes(SchemeGroupVersion,
                &DaemonSet{},
                &DaemonSetList{},
                &Deployment{},
                &DeploymentList{},
                &DeploymentRollback{},
                &autoscaling.Scale{},
                &StatefulSet{},
                &StatefulSetList{},
                &ControllerRevision{},
                &ControllerRevisionList{},
                &ReplicaSet{},
                &ReplicaSetList{},
        )
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        "fmt"
        "strconv"

        appsv1 "k8s.io/api/apps/v1"
        corev1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/kubernetes/pkg/apis/apps"
        "k8s.io/kubernetes/pkg/apis/core"
)

// Convert_apps_DeploymentSpec_To_v1_DeploymentSpec is defined here, because public
// conversion is not auto-generated due to existing warnings.
func Convert_apps_DeploymentSpec_To_v1_DeploymentSpec(in *apps.DeploymentSpec, out *appsv1.DeploymentSpec, s conversion.Scope) error {
        if err := autoConvert_apps_DeploymentSpec_To_v1_DeploymentSpec(in, out, s); err != nil {
                return err
        }
        return nil
}

func Convert_v1_Deployment_To_apps_Deployment(in *appsv1.Deployment, out *apps.Deployment, s conversion.Scope) error {
        if err := autoConvert_v1_Deployment_To_apps_Deployment(in, out, s); err != nil {
                return err
        }

        // Copy annotation to deprecated rollbackTo field for roundtrip
        // TODO: remove this conversion after we delete extensions/v1beta1 and apps/v1beta1 Deployment
        if revision := in.Annotations[appsv1.DeprecatedRollbackTo]; revision != "" {
                if revision64, err := strconv.ParseInt(revision, 10, 64); err != nil {
                        return fmt.Errorf("failed to parse annotation[%s]=%s as int64: %v", appsv1.DeprecatedRollbackTo, revision, err)
                } else {
                        out.Spec.RollbackTo = new(apps.RollbackConfig)
                        out.Spec.RollbackTo.Revision = revision64
                }
                out.Annotations = deepCopyStringMap(out.Annotations)
                delete(out.Annotations, appsv1.DeprecatedRollbackTo)
        } else {
                out.Spec.RollbackTo = nil
        }

        return nil
}

func Convert_apps_Deployment_To_v1_Deployment(in *apps.Deployment, out *appsv1.Deployment, s conversion.Scope) error {
        if err := autoConvert_apps_Deployment_To_v1_Deployment(in, out, s); err != nil {
                return err
        }

        out.Annotations = deepCopyStringMap(out.Annotations) // deep copy because we modify it below

        // Copy deprecated rollbackTo field to annotation for roundtrip
        // TODO: remove this conversion after we delete extensions/v1beta1 and apps/v1beta1 Deployment
        if in.Spec.RollbackTo != nil {
                if out.Annotations == nil {
                        out.Annotations = make(map[string]string)
                }
                out.Annotations[appsv1.DeprecatedRollbackTo] = strconv.FormatInt(in.Spec.RollbackTo.Revision, 10)
        } else {
                delete(out.Annotations, appsv1.DeprecatedRollbackTo)
        }

        return nil
}

func Convert_apps_DaemonSet_To_v1_DaemonSet(in *apps.DaemonSet, out *appsv1.DaemonSet, s conversion.Scope) error {
        if err := autoConvert_apps_DaemonSet_To_v1_DaemonSet(in, out, s); err != nil {
                return err
        }

        out.Annotations = deepCopyStringMap(out.Annotations) // deep copy annotations because we change them below
        out.Annotations[appsv1.DeprecatedTemplateGeneration] = strconv.FormatInt(in.Spec.TemplateGeneration, 10)
        return nil
}

// Convert_apps_DaemonSetSpec_To_v1_DaemonSetSpec is defined here, because public
// conversion is not auto-generated due to existing warnings.
func Convert_apps_DaemonSetSpec_To_v1_DaemonSetSpec(in *apps.DaemonSetSpec, out *appsv1.DaemonSetSpec, s conversion.Scope) error {
        if err := autoConvert_apps_DaemonSetSpec_To_v1_DaemonSetSpec(in, out, s); err != nil {
                return err
        }
        return nil
}

func Convert_v1_DaemonSet_To_apps_DaemonSet(in *appsv1.DaemonSet, out *apps.DaemonSet, s conversion.Scope) error {
        if err := autoConvert_v1_DaemonSet_To_apps_DaemonSet(in, out, s); err != nil {
                return err
        }
        if value, ok := in.Annotations[appsv1.DeprecatedTemplateGeneration]; ok {
                if value64, err := strconv.ParseInt(value, 10, 64); err != nil {
                        return err
                } else {
                        out.Spec.TemplateGeneration = value64
                        out.Annotations = deepCopyStringMap(out.Annotations)
                        delete(out.Annotations, appsv1.DeprecatedTemplateGeneration)
                }
        }
        return nil
}

func deepCopyStringMap(m map[string]string) map[string]string {
        ret := make(map[string]string, len(m))
        for k, v := range m {
                ret[k] = v
        }
        return ret
}

// Convert_apps_StatefulSetSpec_To_v1_StatefulSetSpec augments auto-conversion to preserve < 1.17 behavior
// setting apiVersion/kind in nested persistent volume claim objects.
func Convert_v1_StatefulSetSpec_To_apps_StatefulSetSpec(in *appsv1.StatefulSetSpec, out *apps.StatefulSetSpec, s conversion.Scope) error {
        if err := autoConvert_v1_StatefulSetSpec_To_apps_StatefulSetSpec(in, out, s); err != nil {
                return err
        }
        // set APIVersion/Kind to behave the same as reflective conversion < 1.17.
        // see https://issue.k8s.io/87583
        if out.VolumeClaimTemplates != nil {
                // copy so we don't modify the input
                templatesCopy := make([]core.PersistentVolumeClaim, len(out.VolumeClaimTemplates))
                copy(templatesCopy, out.VolumeClaimTemplates)
                out.VolumeClaimTemplates = templatesCopy
                for i := range out.VolumeClaimTemplates {
                        out.VolumeClaimTemplates[i].APIVersion = ""
                        out.VolumeClaimTemplates[i].Kind = ""
                }
        }
        return nil
}

// Convert_apps_StatefulSetSpec_To_v1_StatefulSetSpec augments auto-conversion to preserve < 1.17 behavior
// setting apiVersion/kind in nested persistent volume claim objects.
func Convert_apps_StatefulSetSpec_To_v1_StatefulSetSpec(in *apps.StatefulSetSpec, out *appsv1.StatefulSetSpec, s conversion.Scope) error {
        if err := autoConvert_apps_StatefulSetSpec_To_v1_StatefulSetSpec(in, out, s); err != nil {
                return err
        }
        // set APIVersion/Kind to behave the same as reflective conversion < 1.17.
        // see https://issue.k8s.io/87583
        if out.VolumeClaimTemplates != nil {
                // copy so we don't modify the input
                templatesCopy := make([]corev1.PersistentVolumeClaim, len(out.VolumeClaimTemplates))
                copy(templatesCopy, out.VolumeClaimTemplates)
                out.VolumeClaimTemplates = templatesCopy
                for i := range out.VolumeClaimTemplates {
                        out.VolumeClaimTemplates[i].APIVersion = "v1"
                        out.VolumeClaimTemplates[i].Kind = "PersistentVolumeClaim"
                }
        }
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        appsv1 "k8s.io/api/apps/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/util/intstr"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        "k8s.io/kubernetes/pkg/features"
        "k8s.io/utils/ptr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

// SetDefaults_Deployment sets additional defaults compared to its counterpart
// in extensions. These addons are:
// - MaxUnavailable during rolling update set to 25% (1 in extensions)
// - MaxSurge value during rolling update set to 25% (1 in extensions)
// - RevisionHistoryLimit set to 10 (not set in extensions)
// - ProgressDeadlineSeconds set to 600s (not set in extensions)
func SetDefaults_Deployment(obj *appsv1.Deployment) {
        // Set DeploymentSpec.Replicas to 1 if it is not set.
        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
        strategy := &obj.Spec.Strategy
        // Set default DeploymentStrategyType as RollingUpdate.
        if strategy.Type == "" {
                strategy.Type = appsv1.RollingUpdateDeploymentStrategyType
        }
        if strategy.Type == appsv1.RollingUpdateDeploymentStrategyType {
                if strategy.RollingUpdate == nil {
                        rollingUpdate := appsv1.RollingUpdateDeployment{}
                        strategy.RollingUpdate = &rollingUpdate
                }
                if strategy.RollingUpdate.MaxUnavailable == nil {
                        // Set default MaxUnavailable as 25% by default.
                        maxUnavailable := intstr.FromString("25%")
                        strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
                }
                if strategy.RollingUpdate.MaxSurge == nil {
                        // Set default MaxSurge as 25% by default.
                        maxSurge := intstr.FromString("25%")
                        strategy.RollingUpdate.MaxSurge = &maxSurge
                }
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 10
        }
        if obj.Spec.ProgressDeadlineSeconds == nil {
                obj.Spec.ProgressDeadlineSeconds = new(int32)
                *obj.Spec.ProgressDeadlineSeconds = 600
        }
}

func SetDefaults_DaemonSet(obj *appsv1.DaemonSet) {
        updateStrategy := &obj.Spec.UpdateStrategy
        if updateStrategy.Type == "" {
                updateStrategy.Type = appsv1.RollingUpdateDaemonSetStrategyType
        }
        if updateStrategy.Type == appsv1.RollingUpdateDaemonSetStrategyType {
                if updateStrategy.RollingUpdate == nil {
                        rollingUpdate := appsv1.RollingUpdateDaemonSet{}
                        updateStrategy.RollingUpdate = &rollingUpdate
                }
                if updateStrategy.RollingUpdate.MaxUnavailable == nil {
                        // Set default MaxUnavailable as 1 by default.
                        updateStrategy.RollingUpdate.MaxUnavailable = ptr.To(intstr.FromInt32(1))
                }
                if updateStrategy.RollingUpdate.MaxSurge == nil {
                        // Set default MaxSurge as 0 by default.
                        updateStrategy.RollingUpdate.MaxSurge = ptr.To(intstr.FromInt32(0))
                }
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 10
        }
}

func SetDefaults_StatefulSet(obj *appsv1.StatefulSet) {
        if len(obj.Spec.PodManagementPolicy) == 0 {
                obj.Spec.PodManagementPolicy = appsv1.OrderedReadyPodManagement
        }

        if obj.Spec.UpdateStrategy.Type == "" {
                obj.Spec.UpdateStrategy.Type = appsv1.RollingUpdateStatefulSetStrategyType

                if obj.Spec.UpdateStrategy.RollingUpdate == nil {
                        // UpdateStrategy.RollingUpdate will take default values below.
                        obj.Spec.UpdateStrategy.RollingUpdate = &appsv1.RollingUpdateStatefulSetStrategy{}
                }
        }

        if obj.Spec.UpdateStrategy.Type == appsv1.RollingUpdateStatefulSetStrategyType &&
                obj.Spec.UpdateStrategy.RollingUpdate != nil {

                if obj.Spec.UpdateStrategy.RollingUpdate.Partition == nil {
                        obj.Spec.UpdateStrategy.RollingUpdate.Partition = ptr.To[int32](0)
                }
                if utilfeature.DefaultFeatureGate.Enabled(features.MaxUnavailableStatefulSet) {
                        if obj.Spec.UpdateStrategy.RollingUpdate.MaxUnavailable == nil {
                                obj.Spec.UpdateStrategy.RollingUpdate.MaxUnavailable = ptr.To(intstr.FromInt32(1))
                        }
                }
        }

        if obj.Spec.PersistentVolumeClaimRetentionPolicy == nil {
                obj.Spec.PersistentVolumeClaimRetentionPolicy = &appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy{}
        }
        if len(obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenDeleted) == 0 {
                obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenDeleted = appsv1.RetainPersistentVolumeClaimRetentionPolicyType
        }
        if len(obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenScaled) == 0 {
                obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenScaled = appsv1.RetainPersistentVolumeClaimRetentionPolicyType
        }

        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 10
        }
}
func SetDefaults_ReplicaSet(obj *appsv1.ReplicaSet) {
        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        appsv1 "k8s.io/api/apps/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "apps"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &appsv1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        appsv1 "k8s.io/api/apps/v1"
        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        intstr "k8s.io/apimachinery/pkg/util/intstr"
        apps "k8s.io/kubernetes/pkg/apis/apps"
        core "k8s.io/kubernetes/pkg/apis/core"
        apiscorev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*appsv1.ControllerRevision)(nil), (*apps.ControllerRevision)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ControllerRevision_To_apps_ControllerRevision(a.(*appsv1.ControllerRevision), b.(*apps.ControllerRevision), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ControllerRevision)(nil), (*appsv1.ControllerRevision)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ControllerRevision_To_v1_ControllerRevision(a.(*apps.ControllerRevision), b.(*appsv1.ControllerRevision), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.ControllerRevisionList)(nil), (*apps.ControllerRevisionList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ControllerRevisionList_To_apps_ControllerRevisionList(a.(*appsv1.ControllerRevisionList), b.(*apps.ControllerRevisionList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ControllerRevisionList)(nil), (*appsv1.ControllerRevisionList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ControllerRevisionList_To_v1_ControllerRevisionList(a.(*apps.ControllerRevisionList), b.(*appsv1.ControllerRevisionList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DaemonSetCondition)(nil), (*apps.DaemonSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DaemonSetCondition_To_apps_DaemonSetCondition(a.(*appsv1.DaemonSetCondition), b.(*apps.DaemonSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetCondition)(nil), (*appsv1.DaemonSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetCondition_To_v1_DaemonSetCondition(a.(*apps.DaemonSetCondition), b.(*appsv1.DaemonSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DaemonSetList)(nil), (*apps.DaemonSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DaemonSetList_To_apps_DaemonSetList(a.(*appsv1.DaemonSetList), b.(*apps.DaemonSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetList)(nil), (*appsv1.DaemonSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetList_To_v1_DaemonSetList(a.(*apps.DaemonSetList), b.(*appsv1.DaemonSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DaemonSetSpec)(nil), (*apps.DaemonSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DaemonSetSpec_To_apps_DaemonSetSpec(a.(*appsv1.DaemonSetSpec), b.(*apps.DaemonSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DaemonSetStatus)(nil), (*apps.DaemonSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DaemonSetStatus_To_apps_DaemonSetStatus(a.(*appsv1.DaemonSetStatus), b.(*apps.DaemonSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetStatus)(nil), (*appsv1.DaemonSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetStatus_To_v1_DaemonSetStatus(a.(*apps.DaemonSetStatus), b.(*appsv1.DaemonSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DaemonSetUpdateStrategy)(nil), (*apps.DaemonSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(a.(*appsv1.DaemonSetUpdateStrategy), b.(*apps.DaemonSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetUpdateStrategy)(nil), (*appsv1.DaemonSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetUpdateStrategy_To_v1_DaemonSetUpdateStrategy(a.(*apps.DaemonSetUpdateStrategy), b.(*appsv1.DaemonSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DeploymentCondition)(nil), (*apps.DeploymentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DeploymentCondition_To_apps_DeploymentCondition(a.(*appsv1.DeploymentCondition), b.(*apps.DeploymentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentCondition)(nil), (*appsv1.DeploymentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentCondition_To_v1_DeploymentCondition(a.(*apps.DeploymentCondition), b.(*appsv1.DeploymentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DeploymentList)(nil), (*apps.DeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DeploymentList_To_apps_DeploymentList(a.(*appsv1.DeploymentList), b.(*apps.DeploymentList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentList)(nil), (*appsv1.DeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentList_To_v1_DeploymentList(a.(*apps.DeploymentList), b.(*appsv1.DeploymentList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DeploymentSpec)(nil), (*apps.DeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DeploymentSpec_To_apps_DeploymentSpec(a.(*appsv1.DeploymentSpec), b.(*apps.DeploymentSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DeploymentStatus)(nil), (*apps.DeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DeploymentStatus_To_apps_DeploymentStatus(a.(*appsv1.DeploymentStatus), b.(*apps.DeploymentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentStatus)(nil), (*appsv1.DeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentStatus_To_v1_DeploymentStatus(a.(*apps.DeploymentStatus), b.(*appsv1.DeploymentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.DeploymentStrategy)(nil), (*apps.DeploymentStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DeploymentStrategy_To_apps_DeploymentStrategy(a.(*appsv1.DeploymentStrategy), b.(*apps.DeploymentStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentStrategy)(nil), (*appsv1.DeploymentStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentStrategy_To_v1_DeploymentStrategy(a.(*apps.DeploymentStrategy), b.(*appsv1.DeploymentStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.ReplicaSet)(nil), (*apps.ReplicaSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicaSet_To_apps_ReplicaSet(a.(*appsv1.ReplicaSet), b.(*apps.ReplicaSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSet)(nil), (*appsv1.ReplicaSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSet_To_v1_ReplicaSet(a.(*apps.ReplicaSet), b.(*appsv1.ReplicaSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.ReplicaSetCondition)(nil), (*apps.ReplicaSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicaSetCondition_To_apps_ReplicaSetCondition(a.(*appsv1.ReplicaSetCondition), b.(*apps.ReplicaSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetCondition)(nil), (*appsv1.ReplicaSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetCondition_To_v1_ReplicaSetCondition(a.(*apps.ReplicaSetCondition), b.(*appsv1.ReplicaSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.ReplicaSetList)(nil), (*apps.ReplicaSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicaSetList_To_apps_ReplicaSetList(a.(*appsv1.ReplicaSetList), b.(*apps.ReplicaSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetList)(nil), (*appsv1.ReplicaSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetList_To_v1_ReplicaSetList(a.(*apps.ReplicaSetList), b.(*appsv1.ReplicaSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.ReplicaSetSpec)(nil), (*apps.ReplicaSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicaSetSpec_To_apps_ReplicaSetSpec(a.(*appsv1.ReplicaSetSpec), b.(*apps.ReplicaSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetSpec)(nil), (*appsv1.ReplicaSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetSpec_To_v1_ReplicaSetSpec(a.(*apps.ReplicaSetSpec), b.(*appsv1.ReplicaSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.ReplicaSetStatus)(nil), (*apps.ReplicaSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicaSetStatus_To_apps_ReplicaSetStatus(a.(*appsv1.ReplicaSetStatus), b.(*apps.ReplicaSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetStatus)(nil), (*appsv1.ReplicaSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetStatus_To_v1_ReplicaSetStatus(a.(*apps.ReplicaSetStatus), b.(*appsv1.ReplicaSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.RollingUpdateDaemonSet)(nil), (*apps.RollingUpdateDaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(a.(*appsv1.RollingUpdateDaemonSet), b.(*apps.RollingUpdateDaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateDaemonSet)(nil), (*appsv1.RollingUpdateDaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateDaemonSet_To_v1_RollingUpdateDaemonSet(a.(*apps.RollingUpdateDaemonSet), b.(*appsv1.RollingUpdateDaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.RollingUpdateDeployment)(nil), (*apps.RollingUpdateDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(a.(*appsv1.RollingUpdateDeployment), b.(*apps.RollingUpdateDeployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateDeployment)(nil), (*appsv1.RollingUpdateDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateDeployment_To_v1_RollingUpdateDeployment(a.(*apps.RollingUpdateDeployment), b.(*appsv1.RollingUpdateDeployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.RollingUpdateStatefulSetStrategy)(nil), (*apps.RollingUpdateStatefulSetStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(a.(*appsv1.RollingUpdateStatefulSetStrategy), b.(*apps.RollingUpdateStatefulSetStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateStatefulSetStrategy)(nil), (*appsv1.RollingUpdateStatefulSetStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateStatefulSetStrategy_To_v1_RollingUpdateStatefulSetStrategy(a.(*apps.RollingUpdateStatefulSetStrategy), b.(*appsv1.RollingUpdateStatefulSetStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.StatefulSet)(nil), (*apps.StatefulSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StatefulSet_To_apps_StatefulSet(a.(*appsv1.StatefulSet), b.(*apps.StatefulSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSet)(nil), (*appsv1.StatefulSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSet_To_v1_StatefulSet(a.(*apps.StatefulSet), b.(*appsv1.StatefulSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.StatefulSetCondition)(nil), (*apps.StatefulSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StatefulSetCondition_To_apps_StatefulSetCondition(a.(*appsv1.StatefulSetCondition), b.(*apps.StatefulSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetCondition)(nil), (*appsv1.StatefulSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetCondition_To_v1_StatefulSetCondition(a.(*apps.StatefulSetCondition), b.(*appsv1.StatefulSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.StatefulSetList)(nil), (*apps.StatefulSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StatefulSetList_To_apps_StatefulSetList(a.(*appsv1.StatefulSetList), b.(*apps.StatefulSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetList)(nil), (*appsv1.StatefulSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetList_To_v1_StatefulSetList(a.(*apps.StatefulSetList), b.(*appsv1.StatefulSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.StatefulSetOrdinals)(nil), (*apps.StatefulSetOrdinals)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(a.(*appsv1.StatefulSetOrdinals), b.(*apps.StatefulSetOrdinals), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetOrdinals)(nil), (*appsv1.StatefulSetOrdinals)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetOrdinals_To_v1_StatefulSetOrdinals(a.(*apps.StatefulSetOrdinals), b.(*appsv1.StatefulSetOrdinals), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), (*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(a.(*appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy), b.(*apps.StatefulSetPersistentVolumeClaimRetentionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), (*appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1_StatefulSetPersistentVolumeClaimRetentionPolicy(a.(*apps.StatefulSetPersistentVolumeClaimRetentionPolicy), b.(*appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.StatefulSetStatus)(nil), (*apps.StatefulSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StatefulSetStatus_To_apps_StatefulSetStatus(a.(*appsv1.StatefulSetStatus), b.(*apps.StatefulSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetStatus)(nil), (*appsv1.StatefulSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetStatus_To_v1_StatefulSetStatus(a.(*apps.StatefulSetStatus), b.(*appsv1.StatefulSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1.StatefulSetUpdateStrategy)(nil), (*apps.StatefulSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(a.(*appsv1.StatefulSetUpdateStrategy), b.(*apps.StatefulSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetUpdateStrategy)(nil), (*appsv1.StatefulSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetUpdateStrategy_To_v1_StatefulSetUpdateStrategy(a.(*apps.StatefulSetUpdateStrategy), b.(*appsv1.StatefulSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.DaemonSetSpec)(nil), (*appsv1.DaemonSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetSpec_To_v1_DaemonSetSpec(a.(*apps.DaemonSetSpec), b.(*appsv1.DaemonSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.DaemonSet)(nil), (*appsv1.DaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSet_To_v1_DaemonSet(a.(*apps.DaemonSet), b.(*appsv1.DaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.DeploymentSpec)(nil), (*appsv1.DeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentSpec_To_v1_DeploymentSpec(a.(*apps.DeploymentSpec), b.(*appsv1.DeploymentSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.Deployment)(nil), (*appsv1.Deployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_Deployment_To_v1_Deployment(a.(*apps.Deployment), b.(*appsv1.Deployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.StatefulSetSpec)(nil), (*appsv1.StatefulSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetSpec_To_v1_StatefulSetSpec(a.(*apps.StatefulSetSpec), b.(*appsv1.StatefulSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1.DaemonSet)(nil), (*apps.DaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DaemonSet_To_apps_DaemonSet(a.(*appsv1.DaemonSet), b.(*apps.DaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1.Deployment)(nil), (*apps.Deployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Deployment_To_apps_Deployment(a.(*appsv1.Deployment), b.(*apps.Deployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1.StatefulSetSpec)(nil), (*apps.StatefulSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StatefulSetSpec_To_apps_StatefulSetSpec(a.(*appsv1.StatefulSetSpec), b.(*apps.StatefulSetSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_ControllerRevision_To_apps_ControllerRevision(in *appsv1.ControllerRevision, out *apps.ControllerRevision, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Data = in.Data
        out.Revision = in.Revision
        return nil
}

// Convert_v1_ControllerRevision_To_apps_ControllerRevision is an autogenerated conversion function.
func Convert_v1_ControllerRevision_To_apps_ControllerRevision(in *appsv1.ControllerRevision, out *apps.ControllerRevision, s conversion.Scope) error {
        return autoConvert_v1_ControllerRevision_To_apps_ControllerRevision(in, out, s)
}

func autoConvert_apps_ControllerRevision_To_v1_ControllerRevision(in *apps.ControllerRevision, out *appsv1.ControllerRevision, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Data = in.Data
        out.Revision = in.Revision
        return nil
}

// Convert_apps_ControllerRevision_To_v1_ControllerRevision is an autogenerated conversion function.
func Convert_apps_ControllerRevision_To_v1_ControllerRevision(in *apps.ControllerRevision, out *appsv1.ControllerRevision, s conversion.Scope) error {
        return autoConvert_apps_ControllerRevision_To_v1_ControllerRevision(in, out, s)
}

func autoConvert_v1_ControllerRevisionList_To_apps_ControllerRevisionList(in *appsv1.ControllerRevisionList, out *apps.ControllerRevisionList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]apps.ControllerRevision)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_ControllerRevisionList_To_apps_ControllerRevisionList is an autogenerated conversion function.
func Convert_v1_ControllerRevisionList_To_apps_ControllerRevisionList(in *appsv1.ControllerRevisionList, out *apps.ControllerRevisionList, s conversion.Scope) error {
        return autoConvert_v1_ControllerRevisionList_To_apps_ControllerRevisionList(in, out, s)
}

func autoConvert_apps_ControllerRevisionList_To_v1_ControllerRevisionList(in *apps.ControllerRevisionList, out *appsv1.ControllerRevisionList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]appsv1.ControllerRevision)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_apps_ControllerRevisionList_To_v1_ControllerRevisionList is an autogenerated conversion function.
func Convert_apps_ControllerRevisionList_To_v1_ControllerRevisionList(in *apps.ControllerRevisionList, out *appsv1.ControllerRevisionList, s conversion.Scope) error {
        return autoConvert_apps_ControllerRevisionList_To_v1_ControllerRevisionList(in, out, s)
}

func autoConvert_v1_DaemonSet_To_apps_DaemonSet(in *appsv1.DaemonSet, out *apps.DaemonSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_DaemonSetSpec_To_apps_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_DaemonSetStatus_To_apps_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_apps_DaemonSet_To_v1_DaemonSet(in *apps.DaemonSet, out *appsv1.DaemonSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_DaemonSetSpec_To_v1_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_DaemonSetStatus_To_v1_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_DaemonSetCondition_To_apps_DaemonSetCondition(in *appsv1.DaemonSetCondition, out *apps.DaemonSetCondition, s conversion.Scope) error {
        out.Type = apps.DaemonSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_DaemonSetCondition_To_apps_DaemonSetCondition is an autogenerated conversion function.
func Convert_v1_DaemonSetCondition_To_apps_DaemonSetCondition(in *appsv1.DaemonSetCondition, out *apps.DaemonSetCondition, s conversion.Scope) error {
        return autoConvert_v1_DaemonSetCondition_To_apps_DaemonSetCondition(in, out, s)
}

func autoConvert_apps_DaemonSetCondition_To_v1_DaemonSetCondition(in *apps.DaemonSetCondition, out *appsv1.DaemonSetCondition, s conversion.Scope) error {
        out.Type = appsv1.DaemonSetConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_DaemonSetCondition_To_v1_DaemonSetCondition is an autogenerated conversion function.
func Convert_apps_DaemonSetCondition_To_v1_DaemonSetCondition(in *apps.DaemonSetCondition, out *appsv1.DaemonSetCondition, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetCondition_To_v1_DaemonSetCondition(in, out, s)
}

func autoConvert_v1_DaemonSetList_To_apps_DaemonSetList(in *appsv1.DaemonSetList, out *apps.DaemonSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.DaemonSet, len(*in))
                for i := range *in {
                        if err := Convert_v1_DaemonSet_To_apps_DaemonSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_DaemonSetList_To_apps_DaemonSetList is an autogenerated conversion function.
func Convert_v1_DaemonSetList_To_apps_DaemonSetList(in *appsv1.DaemonSetList, out *apps.DaemonSetList, s conversion.Scope) error {
        return autoConvert_v1_DaemonSetList_To_apps_DaemonSetList(in, out, s)
}

func autoConvert_apps_DaemonSetList_To_v1_DaemonSetList(in *apps.DaemonSetList, out *appsv1.DaemonSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1.DaemonSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_DaemonSet_To_v1_DaemonSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_DaemonSetList_To_v1_DaemonSetList is an autogenerated conversion function.
func Convert_apps_DaemonSetList_To_v1_DaemonSetList(in *apps.DaemonSetList, out *appsv1.DaemonSetList, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetList_To_v1_DaemonSetList(in, out, s)
}

func autoConvert_v1_DaemonSetSpec_To_apps_DaemonSetSpec(in *appsv1.DaemonSetSpec, out *apps.DaemonSetSpec, s conversion.Scope) error {
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := apiscorev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_v1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        return nil
}

// Convert_v1_DaemonSetSpec_To_apps_DaemonSetSpec is an autogenerated conversion function.
func Convert_v1_DaemonSetSpec_To_apps_DaemonSetSpec(in *appsv1.DaemonSetSpec, out *apps.DaemonSetSpec, s conversion.Scope) error {
        return autoConvert_v1_DaemonSetSpec_To_apps_DaemonSetSpec(in, out, s)
}

func autoConvert_apps_DaemonSetSpec_To_v1_DaemonSetSpec(in *apps.DaemonSetSpec, out *appsv1.DaemonSetSpec, s conversion.Scope) error {
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := apiscorev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_apps_DaemonSetUpdateStrategy_To_v1_DaemonSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        // WARNING: in.TemplateGeneration requires manual conversion: does not exist in peer-type
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        return nil
}

func autoConvert_v1_DaemonSetStatus_To_apps_DaemonSetStatus(in *appsv1.DaemonSetStatus, out *apps.DaemonSetStatus, s conversion.Scope) error {
        out.CurrentNumberScheduled = in.CurrentNumberScheduled
        out.NumberMisscheduled = in.NumberMisscheduled
        out.DesiredNumberScheduled = in.DesiredNumberScheduled
        out.NumberReady = in.NumberReady
        out.ObservedGeneration = in.ObservedGeneration
        out.UpdatedNumberScheduled = in.UpdatedNumberScheduled
        out.NumberAvailable = in.NumberAvailable
        out.NumberUnavailable = in.NumberUnavailable
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]apps.DaemonSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1_DaemonSetStatus_To_apps_DaemonSetStatus is an autogenerated conversion function.
func Convert_v1_DaemonSetStatus_To_apps_DaemonSetStatus(in *appsv1.DaemonSetStatus, out *apps.DaemonSetStatus, s conversion.Scope) error {
        return autoConvert_v1_DaemonSetStatus_To_apps_DaemonSetStatus(in, out, s)
}

func autoConvert_apps_DaemonSetStatus_To_v1_DaemonSetStatus(in *apps.DaemonSetStatus, out *appsv1.DaemonSetStatus, s conversion.Scope) error {
        out.CurrentNumberScheduled = in.CurrentNumberScheduled
        out.NumberMisscheduled = in.NumberMisscheduled
        out.DesiredNumberScheduled = in.DesiredNumberScheduled
        out.NumberReady = in.NumberReady
        out.ObservedGeneration = in.ObservedGeneration
        out.UpdatedNumberScheduled = in.UpdatedNumberScheduled
        out.NumberAvailable = in.NumberAvailable
        out.NumberUnavailable = in.NumberUnavailable
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]appsv1.DaemonSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_apps_DaemonSetStatus_To_v1_DaemonSetStatus is an autogenerated conversion function.
func Convert_apps_DaemonSetStatus_To_v1_DaemonSetStatus(in *apps.DaemonSetStatus, out *appsv1.DaemonSetStatus, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetStatus_To_v1_DaemonSetStatus(in, out, s)
}

func autoConvert_v1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in *appsv1.DaemonSetUpdateStrategy, out *apps.DaemonSetUpdateStrategy, s conversion.Scope) error {
        out.Type = apps.DaemonSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateDaemonSet)
                if err := Convert_v1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy is an autogenerated conversion function.
func Convert_v1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in *appsv1.DaemonSetUpdateStrategy, out *apps.DaemonSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_v1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in, out, s)
}

func autoConvert_apps_DaemonSetUpdateStrategy_To_v1_DaemonSetUpdateStrategy(in *apps.DaemonSetUpdateStrategy, out *appsv1.DaemonSetUpdateStrategy, s conversion.Scope) error {
        out.Type = appsv1.DaemonSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(appsv1.RollingUpdateDaemonSet)
                if err := Convert_apps_RollingUpdateDaemonSet_To_v1_RollingUpdateDaemonSet(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_DaemonSetUpdateStrategy_To_v1_DaemonSetUpdateStrategy is an autogenerated conversion function.
func Convert_apps_DaemonSetUpdateStrategy_To_v1_DaemonSetUpdateStrategy(in *apps.DaemonSetUpdateStrategy, out *appsv1.DaemonSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetUpdateStrategy_To_v1_DaemonSetUpdateStrategy(in, out, s)
}

func autoConvert_v1_Deployment_To_apps_Deployment(in *appsv1.Deployment, out *apps.Deployment, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_DeploymentSpec_To_apps_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_DeploymentStatus_To_apps_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_apps_Deployment_To_v1_Deployment(in *apps.Deployment, out *appsv1.Deployment, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_DeploymentSpec_To_v1_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_DeploymentStatus_To_v1_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_DeploymentCondition_To_apps_DeploymentCondition(in *appsv1.DeploymentCondition, out *apps.DeploymentCondition, s conversion.Scope) error {
        out.Type = apps.DeploymentConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_DeploymentCondition_To_apps_DeploymentCondition is an autogenerated conversion function.
func Convert_v1_DeploymentCondition_To_apps_DeploymentCondition(in *appsv1.DeploymentCondition, out *apps.DeploymentCondition, s conversion.Scope) error {
        return autoConvert_v1_DeploymentCondition_To_apps_DeploymentCondition(in, out, s)
}

func autoConvert_apps_DeploymentCondition_To_v1_DeploymentCondition(in *apps.DeploymentCondition, out *appsv1.DeploymentCondition, s conversion.Scope) error {
        out.Type = appsv1.DeploymentConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_DeploymentCondition_To_v1_DeploymentCondition is an autogenerated conversion function.
func Convert_apps_DeploymentCondition_To_v1_DeploymentCondition(in *apps.DeploymentCondition, out *appsv1.DeploymentCondition, s conversion.Scope) error {
        return autoConvert_apps_DeploymentCondition_To_v1_DeploymentCondition(in, out, s)
}

func autoConvert_v1_DeploymentList_To_apps_DeploymentList(in *appsv1.DeploymentList, out *apps.DeploymentList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.Deployment, len(*in))
                for i := range *in {
                        if err := Convert_v1_Deployment_To_apps_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_DeploymentList_To_apps_DeploymentList is an autogenerated conversion function.
func Convert_v1_DeploymentList_To_apps_DeploymentList(in *appsv1.DeploymentList, out *apps.DeploymentList, s conversion.Scope) error {
        return autoConvert_v1_DeploymentList_To_apps_DeploymentList(in, out, s)
}

func autoConvert_apps_DeploymentList_To_v1_DeploymentList(in *apps.DeploymentList, out *appsv1.DeploymentList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1.Deployment, len(*in))
                for i := range *in {
                        if err := Convert_apps_Deployment_To_v1_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_DeploymentList_To_v1_DeploymentList is an autogenerated conversion function.
func Convert_apps_DeploymentList_To_v1_DeploymentList(in *apps.DeploymentList, out *appsv1.DeploymentList, s conversion.Scope) error {
        return autoConvert_apps_DeploymentList_To_v1_DeploymentList(in, out, s)
}

func autoConvert_v1_DeploymentSpec_To_apps_DeploymentSpec(in *appsv1.DeploymentSpec, out *apps.DeploymentSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := apiscorev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_v1_DeploymentStrategy_To_apps_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.Paused = in.Paused
        out.ProgressDeadlineSeconds = (*int32)(unsafe.Pointer(in.ProgressDeadlineSeconds))
        return nil
}

// Convert_v1_DeploymentSpec_To_apps_DeploymentSpec is an autogenerated conversion function.
func Convert_v1_DeploymentSpec_To_apps_DeploymentSpec(in *appsv1.DeploymentSpec, out *apps.DeploymentSpec, s conversion.Scope) error {
        return autoConvert_v1_DeploymentSpec_To_apps_DeploymentSpec(in, out, s)
}

func autoConvert_apps_DeploymentSpec_To_v1_DeploymentSpec(in *apps.DeploymentSpec, out *appsv1.DeploymentSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := apiscorev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_apps_DeploymentStrategy_To_v1_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.Paused = in.Paused
        // WARNING: in.RollbackTo requires manual conversion: does not exist in peer-type
        out.ProgressDeadlineSeconds = (*int32)(unsafe.Pointer(in.ProgressDeadlineSeconds))
        return nil
}

func autoConvert_v1_DeploymentStatus_To_apps_DeploymentStatus(in *appsv1.DeploymentStatus, out *apps.DeploymentStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Replicas = in.Replicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.UnavailableReplicas = in.UnavailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.Conditions = *(*[]apps.DeploymentCondition)(unsafe.Pointer(&in.Conditions))
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        return nil
}

// Convert_v1_DeploymentStatus_To_apps_DeploymentStatus is an autogenerated conversion function.
func Convert_v1_DeploymentStatus_To_apps_DeploymentStatus(in *appsv1.DeploymentStatus, out *apps.DeploymentStatus, s conversion.Scope) error {
        return autoConvert_v1_DeploymentStatus_To_apps_DeploymentStatus(in, out, s)
}

func autoConvert_apps_DeploymentStatus_To_v1_DeploymentStatus(in *apps.DeploymentStatus, out *appsv1.DeploymentStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Replicas = in.Replicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.UnavailableReplicas = in.UnavailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.Conditions = *(*[]appsv1.DeploymentCondition)(unsafe.Pointer(&in.Conditions))
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        return nil
}

// Convert_apps_DeploymentStatus_To_v1_DeploymentStatus is an autogenerated conversion function.
func Convert_apps_DeploymentStatus_To_v1_DeploymentStatus(in *apps.DeploymentStatus, out *appsv1.DeploymentStatus, s conversion.Scope) error {
        return autoConvert_apps_DeploymentStatus_To_v1_DeploymentStatus(in, out, s)
}

func autoConvert_v1_DeploymentStrategy_To_apps_DeploymentStrategy(in *appsv1.DeploymentStrategy, out *apps.DeploymentStrategy, s conversion.Scope) error {
        out.Type = apps.DeploymentStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateDeployment)
                if err := Convert_v1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1_DeploymentStrategy_To_apps_DeploymentStrategy is an autogenerated conversion function.
func Convert_v1_DeploymentStrategy_To_apps_DeploymentStrategy(in *appsv1.DeploymentStrategy, out *apps.DeploymentStrategy, s conversion.Scope) error {
        return autoConvert_v1_DeploymentStrategy_To_apps_DeploymentStrategy(in, out, s)
}

func autoConvert_apps_DeploymentStrategy_To_v1_DeploymentStrategy(in *apps.DeploymentStrategy, out *appsv1.DeploymentStrategy, s conversion.Scope) error {
        out.Type = appsv1.DeploymentStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(appsv1.RollingUpdateDeployment)
                if err := Convert_apps_RollingUpdateDeployment_To_v1_RollingUpdateDeployment(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_DeploymentStrategy_To_v1_DeploymentStrategy is an autogenerated conversion function.
func Convert_apps_DeploymentStrategy_To_v1_DeploymentStrategy(in *apps.DeploymentStrategy, out *appsv1.DeploymentStrategy, s conversion.Scope) error {
        return autoConvert_apps_DeploymentStrategy_To_v1_DeploymentStrategy(in, out, s)
}

func autoConvert_v1_ReplicaSet_To_apps_ReplicaSet(in *appsv1.ReplicaSet, out *apps.ReplicaSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ReplicaSetSpec_To_apps_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_ReplicaSetStatus_To_apps_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_ReplicaSet_To_apps_ReplicaSet is an autogenerated conversion function.
func Convert_v1_ReplicaSet_To_apps_ReplicaSet(in *appsv1.ReplicaSet, out *apps.ReplicaSet, s conversion.Scope) error {
        return autoConvert_v1_ReplicaSet_To_apps_ReplicaSet(in, out, s)
}

func autoConvert_apps_ReplicaSet_To_v1_ReplicaSet(in *apps.ReplicaSet, out *appsv1.ReplicaSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_ReplicaSetSpec_To_v1_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_ReplicaSetStatus_To_v1_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_ReplicaSet_To_v1_ReplicaSet is an autogenerated conversion function.
func Convert_apps_ReplicaSet_To_v1_ReplicaSet(in *apps.ReplicaSet, out *appsv1.ReplicaSet, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSet_To_v1_ReplicaSet(in, out, s)
}

func autoConvert_v1_ReplicaSetCondition_To_apps_ReplicaSetCondition(in *appsv1.ReplicaSetCondition, out *apps.ReplicaSetCondition, s conversion.Scope) error {
        out.Type = apps.ReplicaSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_ReplicaSetCondition_To_apps_ReplicaSetCondition is an autogenerated conversion function.
func Convert_v1_ReplicaSetCondition_To_apps_ReplicaSetCondition(in *appsv1.ReplicaSetCondition, out *apps.ReplicaSetCondition, s conversion.Scope) error {
        return autoConvert_v1_ReplicaSetCondition_To_apps_ReplicaSetCondition(in, out, s)
}

func autoConvert_apps_ReplicaSetCondition_To_v1_ReplicaSetCondition(in *apps.ReplicaSetCondition, out *appsv1.ReplicaSetCondition, s conversion.Scope) error {
        out.Type = appsv1.ReplicaSetConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_ReplicaSetCondition_To_v1_ReplicaSetCondition is an autogenerated conversion function.
func Convert_apps_ReplicaSetCondition_To_v1_ReplicaSetCondition(in *apps.ReplicaSetCondition, out *appsv1.ReplicaSetCondition, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetCondition_To_v1_ReplicaSetCondition(in, out, s)
}

func autoConvert_v1_ReplicaSetList_To_apps_ReplicaSetList(in *appsv1.ReplicaSetList, out *apps.ReplicaSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.ReplicaSet, len(*in))
                for i := range *in {
                        if err := Convert_v1_ReplicaSet_To_apps_ReplicaSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_ReplicaSetList_To_apps_ReplicaSetList is an autogenerated conversion function.
func Convert_v1_ReplicaSetList_To_apps_ReplicaSetList(in *appsv1.ReplicaSetList, out *apps.ReplicaSetList, s conversion.Scope) error {
        return autoConvert_v1_ReplicaSetList_To_apps_ReplicaSetList(in, out, s)
}

func autoConvert_apps_ReplicaSetList_To_v1_ReplicaSetList(in *apps.ReplicaSetList, out *appsv1.ReplicaSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1.ReplicaSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_ReplicaSet_To_v1_ReplicaSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_ReplicaSetList_To_v1_ReplicaSetList is an autogenerated conversion function.
func Convert_apps_ReplicaSetList_To_v1_ReplicaSetList(in *apps.ReplicaSetList, out *appsv1.ReplicaSetList, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetList_To_v1_ReplicaSetList(in, out, s)
}

func autoConvert_v1_ReplicaSetSpec_To_apps_ReplicaSetSpec(in *appsv1.ReplicaSetSpec, out *apps.ReplicaSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := apiscorev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_ReplicaSetSpec_To_apps_ReplicaSetSpec is an autogenerated conversion function.
func Convert_v1_ReplicaSetSpec_To_apps_ReplicaSetSpec(in *appsv1.ReplicaSetSpec, out *apps.ReplicaSetSpec, s conversion.Scope) error {
        return autoConvert_v1_ReplicaSetSpec_To_apps_ReplicaSetSpec(in, out, s)
}

func autoConvert_apps_ReplicaSetSpec_To_v1_ReplicaSetSpec(in *apps.ReplicaSetSpec, out *appsv1.ReplicaSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := apiscorev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_ReplicaSetSpec_To_v1_ReplicaSetSpec is an autogenerated conversion function.
func Convert_apps_ReplicaSetSpec_To_v1_ReplicaSetSpec(in *apps.ReplicaSetSpec, out *appsv1.ReplicaSetSpec, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetSpec_To_v1_ReplicaSetSpec(in, out, s)
}

func autoConvert_v1_ReplicaSetStatus_To_apps_ReplicaSetStatus(in *appsv1.ReplicaSetStatus, out *apps.ReplicaSetStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.ObservedGeneration = in.ObservedGeneration
        out.Conditions = *(*[]apps.ReplicaSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1_ReplicaSetStatus_To_apps_ReplicaSetStatus is an autogenerated conversion function.
func Convert_v1_ReplicaSetStatus_To_apps_ReplicaSetStatus(in *appsv1.ReplicaSetStatus, out *apps.ReplicaSetStatus, s conversion.Scope) error {
        return autoConvert_v1_ReplicaSetStatus_To_apps_ReplicaSetStatus(in, out, s)
}

func autoConvert_apps_ReplicaSetStatus_To_v1_ReplicaSetStatus(in *apps.ReplicaSetStatus, out *appsv1.ReplicaSetStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.ObservedGeneration = in.ObservedGeneration
        out.Conditions = *(*[]appsv1.ReplicaSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_apps_ReplicaSetStatus_To_v1_ReplicaSetStatus is an autogenerated conversion function.
func Convert_apps_ReplicaSetStatus_To_v1_ReplicaSetStatus(in *apps.ReplicaSetStatus, out *appsv1.ReplicaSetStatus, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetStatus_To_v1_ReplicaSetStatus(in, out, s)
}

func autoConvert_v1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in *appsv1.RollingUpdateDaemonSet, out *apps.RollingUpdateDaemonSet, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet is an autogenerated conversion function.
func Convert_v1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in *appsv1.RollingUpdateDaemonSet, out *apps.RollingUpdateDaemonSet, s conversion.Scope) error {
        return autoConvert_v1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in, out, s)
}

func autoConvert_apps_RollingUpdateDaemonSet_To_v1_RollingUpdateDaemonSet(in *apps.RollingUpdateDaemonSet, out *appsv1.RollingUpdateDaemonSet, s conversion.Scope) error {
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_RollingUpdateDaemonSet_To_v1_RollingUpdateDaemonSet is an autogenerated conversion function.
func Convert_apps_RollingUpdateDaemonSet_To_v1_RollingUpdateDaemonSet(in *apps.RollingUpdateDaemonSet, out *appsv1.RollingUpdateDaemonSet, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateDaemonSet_To_v1_RollingUpdateDaemonSet(in, out, s)
}

func autoConvert_v1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in *appsv1.RollingUpdateDeployment, out *apps.RollingUpdateDeployment, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment is an autogenerated conversion function.
func Convert_v1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in *appsv1.RollingUpdateDeployment, out *apps.RollingUpdateDeployment, s conversion.Scope) error {
        return autoConvert_v1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in, out, s)
}

func autoConvert_apps_RollingUpdateDeployment_To_v1_RollingUpdateDeployment(in *apps.RollingUpdateDeployment, out *appsv1.RollingUpdateDeployment, s conversion.Scope) error {
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_RollingUpdateDeployment_To_v1_RollingUpdateDeployment is an autogenerated conversion function.
func Convert_apps_RollingUpdateDeployment_To_v1_RollingUpdateDeployment(in *apps.RollingUpdateDeployment, out *appsv1.RollingUpdateDeployment, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateDeployment_To_v1_RollingUpdateDeployment(in, out, s)
}

func autoConvert_v1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *appsv1.RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Partition, &out.Partition, s); err != nil {
                return err
        }
        out.MaxUnavailable = (*intstr.IntOrString)(unsafe.Pointer(in.MaxUnavailable))
        return nil
}

// Convert_v1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
func Convert_v1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *appsv1.RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        return autoConvert_v1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in, out, s)
}

func autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *appsv1.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Partition, &out.Partition, s); err != nil {
                return err
        }
        out.MaxUnavailable = (*intstr.IntOrString)(unsafe.Pointer(in.MaxUnavailable))
        return nil
}

// Convert_apps_RollingUpdateStatefulSetStrategy_To_v1_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
func Convert_apps_RollingUpdateStatefulSetStrategy_To_v1_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *appsv1.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1_RollingUpdateStatefulSetStrategy(in, out, s)
}

func autoConvert_v1_StatefulSet_To_apps_StatefulSet(in *appsv1.StatefulSet, out *apps.StatefulSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_StatefulSetSpec_To_apps_StatefulSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_StatefulSetStatus_To_apps_StatefulSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_StatefulSet_To_apps_StatefulSet is an autogenerated conversion function.
func Convert_v1_StatefulSet_To_apps_StatefulSet(in *appsv1.StatefulSet, out *apps.StatefulSet, s conversion.Scope) error {
        return autoConvert_v1_StatefulSet_To_apps_StatefulSet(in, out, s)
}

func autoConvert_apps_StatefulSet_To_v1_StatefulSet(in *apps.StatefulSet, out *appsv1.StatefulSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_StatefulSetSpec_To_v1_StatefulSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_StatefulSetStatus_To_v1_StatefulSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_StatefulSet_To_v1_StatefulSet is an autogenerated conversion function.
func Convert_apps_StatefulSet_To_v1_StatefulSet(in *apps.StatefulSet, out *appsv1.StatefulSet, s conversion.Scope) error {
        return autoConvert_apps_StatefulSet_To_v1_StatefulSet(in, out, s)
}

func autoConvert_v1_StatefulSetCondition_To_apps_StatefulSetCondition(in *appsv1.StatefulSetCondition, out *apps.StatefulSetCondition, s conversion.Scope) error {
        out.Type = apps.StatefulSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_StatefulSetCondition_To_apps_StatefulSetCondition is an autogenerated conversion function.
func Convert_v1_StatefulSetCondition_To_apps_StatefulSetCondition(in *appsv1.StatefulSetCondition, out *apps.StatefulSetCondition, s conversion.Scope) error {
        return autoConvert_v1_StatefulSetCondition_To_apps_StatefulSetCondition(in, out, s)
}

func autoConvert_apps_StatefulSetCondition_To_v1_StatefulSetCondition(in *apps.StatefulSetCondition, out *appsv1.StatefulSetCondition, s conversion.Scope) error {
        out.Type = appsv1.StatefulSetConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_StatefulSetCondition_To_v1_StatefulSetCondition is an autogenerated conversion function.
func Convert_apps_StatefulSetCondition_To_v1_StatefulSetCondition(in *apps.StatefulSetCondition, out *appsv1.StatefulSetCondition, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetCondition_To_v1_StatefulSetCondition(in, out, s)
}

func autoConvert_v1_StatefulSetList_To_apps_StatefulSetList(in *appsv1.StatefulSetList, out *apps.StatefulSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.StatefulSet, len(*in))
                for i := range *in {
                        if err := Convert_v1_StatefulSet_To_apps_StatefulSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_StatefulSetList_To_apps_StatefulSetList is an autogenerated conversion function.
func Convert_v1_StatefulSetList_To_apps_StatefulSetList(in *appsv1.StatefulSetList, out *apps.StatefulSetList, s conversion.Scope) error {
        return autoConvert_v1_StatefulSetList_To_apps_StatefulSetList(in, out, s)
}

func autoConvert_apps_StatefulSetList_To_v1_StatefulSetList(in *apps.StatefulSetList, out *appsv1.StatefulSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1.StatefulSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_StatefulSet_To_v1_StatefulSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_StatefulSetList_To_v1_StatefulSetList is an autogenerated conversion function.
func Convert_apps_StatefulSetList_To_v1_StatefulSetList(in *apps.StatefulSetList, out *appsv1.StatefulSetList, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetList_To_v1_StatefulSetList(in, out, s)
}

func autoConvert_v1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in *appsv1.StatefulSetOrdinals, out *apps.StatefulSetOrdinals, s conversion.Scope) error {
        out.Start = in.Start
        return nil
}

// Convert_v1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals is an autogenerated conversion function.
func Convert_v1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in *appsv1.StatefulSetOrdinals, out *apps.StatefulSetOrdinals, s conversion.Scope) error {
        return autoConvert_v1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in, out, s)
}

func autoConvert_apps_StatefulSetOrdinals_To_v1_StatefulSetOrdinals(in *apps.StatefulSetOrdinals, out *appsv1.StatefulSetOrdinals, s conversion.Scope) error {
        out.Start = in.Start
        return nil
}

// Convert_apps_StatefulSetOrdinals_To_v1_StatefulSetOrdinals is an autogenerated conversion function.
func Convert_apps_StatefulSetOrdinals_To_v1_StatefulSetOrdinals(in *apps.StatefulSetOrdinals, out *appsv1.StatefulSetOrdinals, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetOrdinals_To_v1_StatefulSetOrdinals(in, out, s)
}

func autoConvert_v1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in *appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy, out *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        out.WhenDeleted = apps.PersistentVolumeClaimRetentionPolicyType(in.WhenDeleted)
        out.WhenScaled = apps.PersistentVolumeClaimRetentionPolicyType(in.WhenScaled)
        return nil
}

// Convert_v1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy is an autogenerated conversion function.
func Convert_v1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in *appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy, out *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        return autoConvert_v1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in, out, s)
}

func autoConvert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1_StatefulSetPersistentVolumeClaimRetentionPolicy(in *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, out *appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        out.WhenDeleted = appsv1.PersistentVolumeClaimRetentionPolicyType(in.WhenDeleted)
        out.WhenScaled = appsv1.PersistentVolumeClaimRetentionPolicyType(in.WhenScaled)
        return nil
}

// Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1_StatefulSetPersistentVolumeClaimRetentionPolicy is an autogenerated conversion function.
func Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1_StatefulSetPersistentVolumeClaimRetentionPolicy(in *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, out *appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1_StatefulSetPersistentVolumeClaimRetentionPolicy(in, out, s)
}

func autoConvert_v1_StatefulSetSpec_To_apps_StatefulSetSpec(in *appsv1.StatefulSetSpec, out *apps.StatefulSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := apiscorev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        out.VolumeClaimTemplates = *(*[]core.PersistentVolumeClaim)(unsafe.Pointer(&in.VolumeClaimTemplates))
        out.ServiceName = in.ServiceName
        out.PodManagementPolicy = apps.PodManagementPolicyType(in.PodManagementPolicy)
        if err := Convert_v1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.MinReadySeconds = in.MinReadySeconds
        out.PersistentVolumeClaimRetentionPolicy = (*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(unsafe.Pointer(in.PersistentVolumeClaimRetentionPolicy))
        out.Ordinals = (*apps.StatefulSetOrdinals)(unsafe.Pointer(in.Ordinals))
        return nil
}

func autoConvert_apps_StatefulSetSpec_To_v1_StatefulSetSpec(in *apps.StatefulSetSpec, out *appsv1.StatefulSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := apiscorev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        out.VolumeClaimTemplates = *(*[]corev1.PersistentVolumeClaim)(unsafe.Pointer(&in.VolumeClaimTemplates))
        out.ServiceName = in.ServiceName
        out.PodManagementPolicy = appsv1.PodManagementPolicyType(in.PodManagementPolicy)
        if err := Convert_apps_StatefulSetUpdateStrategy_To_v1_StatefulSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.MinReadySeconds = in.MinReadySeconds
        out.PersistentVolumeClaimRetentionPolicy = (*appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy)(unsafe.Pointer(in.PersistentVolumeClaimRetentionPolicy))
        out.Ordinals = (*appsv1.StatefulSetOrdinals)(unsafe.Pointer(in.Ordinals))
        return nil
}

func autoConvert_v1_StatefulSetStatus_To_apps_StatefulSetStatus(in *appsv1.StatefulSetStatus, out *apps.StatefulSetStatus, s conversion.Scope) error {
        if err := metav1.Convert_int64_To_Pointer_int64(&in.ObservedGeneration, &out.ObservedGeneration, s); err != nil {
                return err
        }
        out.Replicas = in.Replicas
        out.ReadyReplicas = in.ReadyReplicas
        out.CurrentReplicas = in.CurrentReplicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.CurrentRevision = in.CurrentRevision
        out.UpdateRevision = in.UpdateRevision
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]apps.StatefulSetCondition)(unsafe.Pointer(&in.Conditions))
        out.AvailableReplicas = in.AvailableReplicas
        return nil
}

// Convert_v1_StatefulSetStatus_To_apps_StatefulSetStatus is an autogenerated conversion function.
func Convert_v1_StatefulSetStatus_To_apps_StatefulSetStatus(in *appsv1.StatefulSetStatus, out *apps.StatefulSetStatus, s conversion.Scope) error {
        return autoConvert_v1_StatefulSetStatus_To_apps_StatefulSetStatus(in, out, s)
}

func autoConvert_apps_StatefulSetStatus_To_v1_StatefulSetStatus(in *apps.StatefulSetStatus, out *appsv1.StatefulSetStatus, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int64_To_int64(&in.ObservedGeneration, &out.ObservedGeneration, s); err != nil {
                return err
        }
        out.Replicas = in.Replicas
        out.ReadyReplicas = in.ReadyReplicas
        out.CurrentReplicas = in.CurrentReplicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.CurrentRevision = in.CurrentRevision
        out.UpdateRevision = in.UpdateRevision
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]appsv1.StatefulSetCondition)(unsafe.Pointer(&in.Conditions))
        out.AvailableReplicas = in.AvailableReplicas
        return nil
}

// Convert_apps_StatefulSetStatus_To_v1_StatefulSetStatus is an autogenerated conversion function.
func Convert_apps_StatefulSetStatus_To_v1_StatefulSetStatus(in *apps.StatefulSetStatus, out *appsv1.StatefulSetStatus, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetStatus_To_v1_StatefulSetStatus(in, out, s)
}

func autoConvert_v1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in *appsv1.StatefulSetUpdateStrategy, out *apps.StatefulSetUpdateStrategy, s conversion.Scope) error {
        out.Type = apps.StatefulSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateStatefulSetStrategy)
                if err := Convert_v1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy is an autogenerated conversion function.
func Convert_v1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in *appsv1.StatefulSetUpdateStrategy, out *apps.StatefulSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_v1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in, out, s)
}

func autoConvert_apps_StatefulSetUpdateStrategy_To_v1_StatefulSetUpdateStrategy(in *apps.StatefulSetUpdateStrategy, out *appsv1.StatefulSetUpdateStrategy, s conversion.Scope) error {
        out.Type = appsv1.StatefulSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(appsv1.RollingUpdateStatefulSetStrategy)
                if err := Convert_apps_RollingUpdateStatefulSetStrategy_To_v1_RollingUpdateStatefulSetStrategy(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_StatefulSetUpdateStrategy_To_v1_StatefulSetUpdateStrategy is an autogenerated conversion function.
func Convert_apps_StatefulSetUpdateStrategy_To_v1_StatefulSetUpdateStrategy(in *apps.StatefulSetUpdateStrategy, out *appsv1.StatefulSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetUpdateStrategy_To_v1_StatefulSetUpdateStrategy(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        appsv1 "k8s.io/api/apps/v1"
        corev1 "k8s.io/api/core/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        apiscorev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&appsv1.DaemonSet{}, func(obj interface{}) { SetObjectDefaults_DaemonSet(obj.(*appsv1.DaemonSet)) })
        scheme.AddTypeDefaultingFunc(&appsv1.DaemonSetList{}, func(obj interface{}) { SetObjectDefaults_DaemonSetList(obj.(*appsv1.DaemonSetList)) })
        scheme.AddTypeDefaultingFunc(&appsv1.Deployment{}, func(obj interface{}) { SetObjectDefaults_Deployment(obj.(*appsv1.Deployment)) })
        scheme.AddTypeDefaultingFunc(&appsv1.DeploymentList{}, func(obj interface{}) { SetObjectDefaults_DeploymentList(obj.(*appsv1.DeploymentList)) })
        scheme.AddTypeDefaultingFunc(&appsv1.ReplicaSet{}, func(obj interface{}) { SetObjectDefaults_ReplicaSet(obj.(*appsv1.ReplicaSet)) })
        scheme.AddTypeDefaultingFunc(&appsv1.ReplicaSetList{}, func(obj interface{}) { SetObjectDefaults_ReplicaSetList(obj.(*appsv1.ReplicaSetList)) })
        scheme.AddTypeDefaultingFunc(&appsv1.StatefulSet{}, func(obj interface{}) { SetObjectDefaults_StatefulSet(obj.(*appsv1.StatefulSet)) })
        scheme.AddTypeDefaultingFunc(&appsv1.StatefulSetList{}, func(obj interface{}) { SetObjectDefaults_StatefulSetList(obj.(*appsv1.StatefulSetList)) })
        return nil
}

func SetObjectDefaults_DaemonSet(in *appsv1.DaemonSet) {
        SetDefaults_DaemonSet(in)
        apiscorev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                apiscorev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        apiscorev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        apiscorev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        apiscorev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        apiscorev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        apiscorev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        apiscorev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        apiscorev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                apiscorev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                apiscorev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_DaemonSetList(in *appsv1.DaemonSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_DaemonSet(a)
        }
}

func SetObjectDefaults_Deployment(in *appsv1.Deployment) {
        SetDefaults_Deployment(in)
        apiscorev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                apiscorev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        apiscorev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        apiscorev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        apiscorev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        apiscorev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        apiscorev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        apiscorev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        apiscorev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                apiscorev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                apiscorev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_DeploymentList(in *appsv1.DeploymentList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Deployment(a)
        }
}

func SetObjectDefaults_ReplicaSet(in *appsv1.ReplicaSet) {
        SetDefaults_ReplicaSet(in)
        apiscorev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                apiscorev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        apiscorev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        apiscorev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        apiscorev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        apiscorev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        apiscorev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        apiscorev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        apiscorev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                apiscorev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                apiscorev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_ReplicaSetList(in *appsv1.ReplicaSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ReplicaSet(a)
        }
}

func SetObjectDefaults_StatefulSet(in *appsv1.StatefulSet) {
        SetDefaults_StatefulSet(in)
        apiscorev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                apiscorev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        apiscorev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        apiscorev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        apiscorev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        apiscorev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        apiscorev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        apiscorev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        apiscorev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                apiscorev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                apiscorev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
        for i := range in.Spec.VolumeClaimTemplates {
                a := &in.Spec.VolumeClaimTemplates[i]
                apiscorev1.SetDefaults_PersistentVolumeClaim(a)
                apiscorev1.SetDefaults_PersistentVolumeClaimSpec(&a.Spec)
                apiscorev1.SetDefaults_ResourceList(&a.Spec.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Spec.Resources.Requests)
                apiscorev1.SetDefaults_ResourceList(&a.Status.Capacity)
                apiscorev1.SetDefaults_ResourceList(&a.Status.AllocatedResources)
        }
}

func SetObjectDefaults_StatefulSetList(in *appsv1.StatefulSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_StatefulSet(a)
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "fmt"

        appsv1beta1 "k8s.io/api/apps/v1beta1"
        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/apimachinery/pkg/runtime"
        apps "k8s.io/kubernetes/pkg/apis/apps"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/kubernetes/pkg/apis/core"
)

func addConversionFuncs(scheme *runtime.Scheme) error {
        // Add field label conversions for kinds having selectable nothing but ObjectMeta fields.
        if err := scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("StatefulSet"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name", "metadata.namespace", "status.successful":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported for appsv1beta1.StatefulSet: %s", label)
                        }
                }); err != nil {
                return err
        }

        return nil
}

func Convert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(in *autoscaling.ScaleStatus, out *appsv1beta1.ScaleStatus, s conversion.Scope) error {
        out.Replicas = int32(in.Replicas)
        out.TargetSelector = in.Selector

        out.Selector = nil
        selector, err := metav1.ParseToLabelSelector(in.Selector)
        if err != nil {
                return fmt.Errorf("failed to parse selector: %v", err)
        }
        if len(selector.MatchExpressions) == 0 {
                out.Selector = selector.MatchLabels
        }

        return nil
}

func Convert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(in *appsv1beta1.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas

        if in.TargetSelector != "" {
                out.Selector = in.TargetSelector
        } else if in.Selector != nil {
                set := labels.Set{}
                for key, val := range in.Selector {
                        set[key] = val
                }
                out.Selector = labels.SelectorFromSet(set).String()
        } else {
                out.Selector = ""
        }
        return nil
}

// Convert_v1beta1_StatefulSetSpec_To_apps_StatefulSetSpec augments auto-conversion to preserve < 1.17 behavior
// setting apiVersion/kind in nested persistent volume claim objects.
func Convert_v1beta1_StatefulSetSpec_To_apps_StatefulSetSpec(in *appsv1beta1.StatefulSetSpec, out *apps.StatefulSetSpec, s conversion.Scope) error {
        if err := autoConvert_v1beta1_StatefulSetSpec_To_apps_StatefulSetSpec(in, out, s); err != nil {
                return err
        }
        // set APIVersion/Kind to behave the same as reflective conversion < 1.17.
        // see https://issue.k8s.io/87583
        if out.VolumeClaimTemplates != nil {
                // copy so we don't modify the input
                templatesCopy := make([]core.PersistentVolumeClaim, len(out.VolumeClaimTemplates))
                copy(templatesCopy, out.VolumeClaimTemplates)
                out.VolumeClaimTemplates = templatesCopy
                for i := range out.VolumeClaimTemplates {
                        out.VolumeClaimTemplates[i].APIVersion = ""
                        out.VolumeClaimTemplates[i].Kind = ""
                }
        }
        return nil
}

// Convert_apps_StatefulSetSpec_To_v1beta1_StatefulSetSpec augments auto-conversion to preserve < 1.17 behavior
// setting apiVersion/kind in nested persistent volume claim objects.
func Convert_apps_StatefulSetSpec_To_v1beta1_StatefulSetSpec(in *apps.StatefulSetSpec, out *appsv1beta1.StatefulSetSpec, s conversion.Scope) error {
        if err := autoConvert_apps_StatefulSetSpec_To_v1beta1_StatefulSetSpec(in, out, s); err != nil {
                return err
        }
        // set APIVersion/Kind to behave the same as reflective conversion < 1.17.
        // see https://issue.k8s.io/87583
        if out.VolumeClaimTemplates != nil {
                // copy so we don't modify the input
                templatesCopy := make([]corev1.PersistentVolumeClaim, len(out.VolumeClaimTemplates))
                copy(templatesCopy, out.VolumeClaimTemplates)
                out.VolumeClaimTemplates = templatesCopy
                for i := range out.VolumeClaimTemplates {
                        out.VolumeClaimTemplates[i].APIVersion = "v1"
                        out.VolumeClaimTemplates[i].Kind = "PersistentVolumeClaim"
                }
        }
        return nil
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        appsv1beta1 "k8s.io/api/apps/v1beta1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/util/intstr"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        "k8s.io/kubernetes/pkg/features"
        "k8s.io/utils/ptr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_StatefulSet(obj *appsv1beta1.StatefulSet) {
        if len(obj.Spec.PodManagementPolicy) == 0 {
                obj.Spec.PodManagementPolicy = appsv1beta1.OrderedReadyPodManagement
        }

        if obj.Spec.UpdateStrategy.Type == "" {
                obj.Spec.UpdateStrategy.Type = appsv1beta1.OnDeleteStatefulSetStrategyType
        }
        labels := obj.Spec.Template.Labels
        if labels != nil {
                if obj.Spec.Selector == nil {
                        obj.Spec.Selector = &metav1.LabelSelector{
                                MatchLabels: labels,
                        }
                }
                if len(obj.Labels) == 0 {
                        obj.Labels = labels
                }
        }

        if obj.Spec.PersistentVolumeClaimRetentionPolicy == nil {
                obj.Spec.PersistentVolumeClaimRetentionPolicy = &appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy{}
        }
        if len(obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenDeleted) == 0 {
                obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenDeleted = appsv1beta1.RetainPersistentVolumeClaimRetentionPolicyType
        }
        if len(obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenScaled) == 0 {
                obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenScaled = appsv1beta1.RetainPersistentVolumeClaimRetentionPolicyType
        }

        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 10
        }
        if obj.Spec.UpdateStrategy.Type == appsv1beta1.RollingUpdateStatefulSetStrategyType &&
                obj.Spec.UpdateStrategy.RollingUpdate != nil {

                if obj.Spec.UpdateStrategy.RollingUpdate.Partition == nil {
                        obj.Spec.UpdateStrategy.RollingUpdate.Partition = ptr.To[int32](0)
                }
                if utilfeature.DefaultFeatureGate.Enabled(features.MaxUnavailableStatefulSet) {
                        if obj.Spec.UpdateStrategy.RollingUpdate.MaxUnavailable == nil {
                                obj.Spec.UpdateStrategy.RollingUpdate.MaxUnavailable = ptr.To(intstr.FromInt32(1))
                        }
                }
        }
}

// SetDefaults_Deployment sets additional defaults compared to its counterpart
// in extensions. These addons are:
// - MaxUnavailable during rolling update set to 25% (1 in extensions)
// - MaxSurge value during rolling update set to 25% (1 in extensions)
// - RevisionHistoryLimit set to 2 (not set in extensions)
// - ProgressDeadlineSeconds set to 600s (not set in extensions)
func SetDefaults_Deployment(obj *appsv1beta1.Deployment) {
        // Default labels and selector to labels from pod template spec.
        labels := obj.Spec.Template.Labels

        if labels != nil {
                if obj.Spec.Selector == nil {
                        obj.Spec.Selector = &metav1.LabelSelector{MatchLabels: labels}
                }
                if len(obj.Labels) == 0 {
                        obj.Labels = labels
                }
        }
        // Set appsv1beta1.DeploymentSpec.Replicas to 1 if it is not set.
        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
        strategy := &obj.Spec.Strategy
        // Set default appsv1beta1.DeploymentStrategyType as RollingUpdate.
        if strategy.Type == "" {
                strategy.Type = appsv1beta1.RollingUpdateDeploymentStrategyType
        }
        if strategy.Type == appsv1beta1.RollingUpdateDeploymentStrategyType {
                if strategy.RollingUpdate == nil {
                        rollingUpdate := appsv1beta1.RollingUpdateDeployment{}
                        strategy.RollingUpdate = &rollingUpdate
                }
                if strategy.RollingUpdate.MaxUnavailable == nil {
                        // Set default MaxUnavailable as 25% by default.
                        maxUnavailable := intstr.FromString("25%")
                        strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
                }
                if strategy.RollingUpdate.MaxSurge == nil {
                        // Set default MaxSurge as 25% by default.
                        maxSurge := intstr.FromString("25%")
                        strategy.RollingUpdate.MaxSurge = &maxSurge
                }
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 2
        }
        if obj.Spec.ProgressDeadlineSeconds == nil {
                obj.Spec.ProgressDeadlineSeconds = new(int32)
                *obj.Spec.ProgressDeadlineSeconds = 600
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        appsv1beta1 "k8s.io/api/apps/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "apps"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &appsv1beta1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        appsv1beta1 "k8s.io/api/apps/v1beta1"
        v1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        intstr "k8s.io/apimachinery/pkg/util/intstr"
        apps "k8s.io/kubernetes/pkg/apis/apps"
        autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
        core "k8s.io/kubernetes/pkg/apis/core"
        corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.ControllerRevision)(nil), (*apps.ControllerRevision)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ControllerRevision_To_apps_ControllerRevision(a.(*appsv1beta1.ControllerRevision), b.(*apps.ControllerRevision), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ControllerRevision)(nil), (*appsv1beta1.ControllerRevision)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ControllerRevision_To_v1beta1_ControllerRevision(a.(*apps.ControllerRevision), b.(*appsv1beta1.ControllerRevision), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.ControllerRevisionList)(nil), (*apps.ControllerRevisionList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ControllerRevisionList_To_apps_ControllerRevisionList(a.(*appsv1beta1.ControllerRevisionList), b.(*apps.ControllerRevisionList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ControllerRevisionList)(nil), (*appsv1beta1.ControllerRevisionList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ControllerRevisionList_To_v1beta1_ControllerRevisionList(a.(*apps.ControllerRevisionList), b.(*appsv1beta1.ControllerRevisionList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.Deployment)(nil), (*apps.Deployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Deployment_To_apps_Deployment(a.(*appsv1beta1.Deployment), b.(*apps.Deployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.Deployment)(nil), (*appsv1beta1.Deployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_Deployment_To_v1beta1_Deployment(a.(*apps.Deployment), b.(*appsv1beta1.Deployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.DeploymentCondition)(nil), (*apps.DeploymentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition(a.(*appsv1beta1.DeploymentCondition), b.(*apps.DeploymentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentCondition)(nil), (*appsv1beta1.DeploymentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition(a.(*apps.DeploymentCondition), b.(*appsv1beta1.DeploymentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.DeploymentList)(nil), (*apps.DeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentList_To_apps_DeploymentList(a.(*appsv1beta1.DeploymentList), b.(*apps.DeploymentList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentList)(nil), (*appsv1beta1.DeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentList_To_v1beta1_DeploymentList(a.(*apps.DeploymentList), b.(*appsv1beta1.DeploymentList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.DeploymentRollback)(nil), (*apps.DeploymentRollback)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback(a.(*appsv1beta1.DeploymentRollback), b.(*apps.DeploymentRollback), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentRollback)(nil), (*appsv1beta1.DeploymentRollback)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback(a.(*apps.DeploymentRollback), b.(*appsv1beta1.DeploymentRollback), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.DeploymentSpec)(nil), (*apps.DeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(a.(*appsv1beta1.DeploymentSpec), b.(*apps.DeploymentSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentSpec)(nil), (*appsv1beta1.DeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(a.(*apps.DeploymentSpec), b.(*appsv1beta1.DeploymentSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.DeploymentStatus)(nil), (*apps.DeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(a.(*appsv1beta1.DeploymentStatus), b.(*apps.DeploymentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentStatus)(nil), (*appsv1beta1.DeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(a.(*apps.DeploymentStatus), b.(*appsv1beta1.DeploymentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.DeploymentStrategy)(nil), (*apps.DeploymentStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(a.(*appsv1beta1.DeploymentStrategy), b.(*apps.DeploymentStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentStrategy)(nil), (*appsv1beta1.DeploymentStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(a.(*apps.DeploymentStrategy), b.(*appsv1beta1.DeploymentStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.RollbackConfig)(nil), (*apps.RollbackConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_RollbackConfig_To_apps_RollbackConfig(a.(*appsv1beta1.RollbackConfig), b.(*apps.RollbackConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollbackConfig)(nil), (*appsv1beta1.RollbackConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollbackConfig_To_v1beta1_RollbackConfig(a.(*apps.RollbackConfig), b.(*appsv1beta1.RollbackConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.RollingUpdateDeployment)(nil), (*apps.RollingUpdateDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(a.(*appsv1beta1.RollingUpdateDeployment), b.(*apps.RollingUpdateDeployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateDeployment)(nil), (*appsv1beta1.RollingUpdateDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(a.(*apps.RollingUpdateDeployment), b.(*appsv1beta1.RollingUpdateDeployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.RollingUpdateStatefulSetStrategy)(nil), (*apps.RollingUpdateStatefulSetStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(a.(*appsv1beta1.RollingUpdateStatefulSetStrategy), b.(*apps.RollingUpdateStatefulSetStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateStatefulSetStrategy)(nil), (*appsv1beta1.RollingUpdateStatefulSetStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(a.(*apps.RollingUpdateStatefulSetStrategy), b.(*appsv1beta1.RollingUpdateStatefulSetStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.Scale)(nil), (*autoscaling.Scale)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Scale_To_autoscaling_Scale(a.(*appsv1beta1.Scale), b.(*autoscaling.Scale), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.Scale)(nil), (*appsv1beta1.Scale)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_Scale_To_v1beta1_Scale(a.(*autoscaling.Scale), b.(*appsv1beta1.Scale), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.ScaleSpec)(nil), (*autoscaling.ScaleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(a.(*appsv1beta1.ScaleSpec), b.(*autoscaling.ScaleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ScaleSpec)(nil), (*appsv1beta1.ScaleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(a.(*autoscaling.ScaleSpec), b.(*appsv1beta1.ScaleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.StatefulSet)(nil), (*apps.StatefulSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_StatefulSet_To_apps_StatefulSet(a.(*appsv1beta1.StatefulSet), b.(*apps.StatefulSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSet)(nil), (*appsv1beta1.StatefulSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSet_To_v1beta1_StatefulSet(a.(*apps.StatefulSet), b.(*appsv1beta1.StatefulSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.StatefulSetCondition)(nil), (*apps.StatefulSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_StatefulSetCondition_To_apps_StatefulSetCondition(a.(*appsv1beta1.StatefulSetCondition), b.(*apps.StatefulSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetCondition)(nil), (*appsv1beta1.StatefulSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetCondition_To_v1beta1_StatefulSetCondition(a.(*apps.StatefulSetCondition), b.(*appsv1beta1.StatefulSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.StatefulSetList)(nil), (*apps.StatefulSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_StatefulSetList_To_apps_StatefulSetList(a.(*appsv1beta1.StatefulSetList), b.(*apps.StatefulSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetList)(nil), (*appsv1beta1.StatefulSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetList_To_v1beta1_StatefulSetList(a.(*apps.StatefulSetList), b.(*appsv1beta1.StatefulSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.StatefulSetOrdinals)(nil), (*apps.StatefulSetOrdinals)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(a.(*appsv1beta1.StatefulSetOrdinals), b.(*apps.StatefulSetOrdinals), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetOrdinals)(nil), (*appsv1beta1.StatefulSetOrdinals)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetOrdinals_To_v1beta1_StatefulSetOrdinals(a.(*apps.StatefulSetOrdinals), b.(*appsv1beta1.StatefulSetOrdinals), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), (*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(a.(*appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy), b.(*apps.StatefulSetPersistentVolumeClaimRetentionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), (*appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy(a.(*apps.StatefulSetPersistentVolumeClaimRetentionPolicy), b.(*appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.StatefulSetStatus)(nil), (*apps.StatefulSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_StatefulSetStatus_To_apps_StatefulSetStatus(a.(*appsv1beta1.StatefulSetStatus), b.(*apps.StatefulSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetStatus)(nil), (*appsv1beta1.StatefulSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetStatus_To_v1beta1_StatefulSetStatus(a.(*apps.StatefulSetStatus), b.(*appsv1beta1.StatefulSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta1.StatefulSetUpdateStrategy)(nil), (*apps.StatefulSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(a.(*appsv1beta1.StatefulSetUpdateStrategy), b.(*apps.StatefulSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetUpdateStrategy)(nil), (*appsv1beta1.StatefulSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetUpdateStrategy_To_v1beta1_StatefulSetUpdateStrategy(a.(*apps.StatefulSetUpdateStrategy), b.(*appsv1beta1.StatefulSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.StatefulSetSpec)(nil), (*appsv1beta1.StatefulSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetSpec_To_v1beta1_StatefulSetSpec(a.(*apps.StatefulSetSpec), b.(*appsv1beta1.StatefulSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ScaleStatus)(nil), (*appsv1beta1.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(a.(*autoscaling.ScaleStatus), b.(*appsv1beta1.ScaleStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1beta1.ScaleStatus)(nil), (*autoscaling.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(a.(*appsv1beta1.ScaleStatus), b.(*autoscaling.ScaleStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1beta1.StatefulSetSpec)(nil), (*apps.StatefulSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_StatefulSetSpec_To_apps_StatefulSetSpec(a.(*appsv1beta1.StatefulSetSpec), b.(*apps.StatefulSetSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_ControllerRevision_To_apps_ControllerRevision(in *appsv1beta1.ControllerRevision, out *apps.ControllerRevision, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Data = in.Data
        out.Revision = in.Revision
        return nil
}

// Convert_v1beta1_ControllerRevision_To_apps_ControllerRevision is an autogenerated conversion function.
func Convert_v1beta1_ControllerRevision_To_apps_ControllerRevision(in *appsv1beta1.ControllerRevision, out *apps.ControllerRevision, s conversion.Scope) error {
        return autoConvert_v1beta1_ControllerRevision_To_apps_ControllerRevision(in, out, s)
}

func autoConvert_apps_ControllerRevision_To_v1beta1_ControllerRevision(in *apps.ControllerRevision, out *appsv1beta1.ControllerRevision, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Data = in.Data
        out.Revision = in.Revision
        return nil
}

// Convert_apps_ControllerRevision_To_v1beta1_ControllerRevision is an autogenerated conversion function.
func Convert_apps_ControllerRevision_To_v1beta1_ControllerRevision(in *apps.ControllerRevision, out *appsv1beta1.ControllerRevision, s conversion.Scope) error {
        return autoConvert_apps_ControllerRevision_To_v1beta1_ControllerRevision(in, out, s)
}

func autoConvert_v1beta1_ControllerRevisionList_To_apps_ControllerRevisionList(in *appsv1beta1.ControllerRevisionList, out *apps.ControllerRevisionList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]apps.ControllerRevision)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1beta1_ControllerRevisionList_To_apps_ControllerRevisionList is an autogenerated conversion function.
func Convert_v1beta1_ControllerRevisionList_To_apps_ControllerRevisionList(in *appsv1beta1.ControllerRevisionList, out *apps.ControllerRevisionList, s conversion.Scope) error {
        return autoConvert_v1beta1_ControllerRevisionList_To_apps_ControllerRevisionList(in, out, s)
}

func autoConvert_apps_ControllerRevisionList_To_v1beta1_ControllerRevisionList(in *apps.ControllerRevisionList, out *appsv1beta1.ControllerRevisionList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]appsv1beta1.ControllerRevision)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_apps_ControllerRevisionList_To_v1beta1_ControllerRevisionList is an autogenerated conversion function.
func Convert_apps_ControllerRevisionList_To_v1beta1_ControllerRevisionList(in *apps.ControllerRevisionList, out *appsv1beta1.ControllerRevisionList, s conversion.Scope) error {
        return autoConvert_apps_ControllerRevisionList_To_v1beta1_ControllerRevisionList(in, out, s)
}

func autoConvert_v1beta1_Deployment_To_apps_Deployment(in *appsv1beta1.Deployment, out *apps.Deployment, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_Deployment_To_apps_Deployment is an autogenerated conversion function.
func Convert_v1beta1_Deployment_To_apps_Deployment(in *appsv1beta1.Deployment, out *apps.Deployment, s conversion.Scope) error {
        return autoConvert_v1beta1_Deployment_To_apps_Deployment(in, out, s)
}

func autoConvert_apps_Deployment_To_v1beta1_Deployment(in *apps.Deployment, out *appsv1beta1.Deployment, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_Deployment_To_v1beta1_Deployment is an autogenerated conversion function.
func Convert_apps_Deployment_To_v1beta1_Deployment(in *apps.Deployment, out *appsv1beta1.Deployment, s conversion.Scope) error {
        return autoConvert_apps_Deployment_To_v1beta1_Deployment(in, out, s)
}

func autoConvert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition(in *appsv1beta1.DeploymentCondition, out *apps.DeploymentCondition, s conversion.Scope) error {
        out.Type = apps.DeploymentConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition is an autogenerated conversion function.
func Convert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition(in *appsv1beta1.DeploymentCondition, out *apps.DeploymentCondition, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition(in, out, s)
}

func autoConvert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition(in *apps.DeploymentCondition, out *appsv1beta1.DeploymentCondition, s conversion.Scope) error {
        out.Type = appsv1beta1.DeploymentConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition is an autogenerated conversion function.
func Convert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition(in *apps.DeploymentCondition, out *appsv1beta1.DeploymentCondition, s conversion.Scope) error {
        return autoConvert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition(in, out, s)
}

func autoConvert_v1beta1_DeploymentList_To_apps_DeploymentList(in *appsv1beta1.DeploymentList, out *apps.DeploymentList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.Deployment, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_Deployment_To_apps_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_DeploymentList_To_apps_DeploymentList is an autogenerated conversion function.
func Convert_v1beta1_DeploymentList_To_apps_DeploymentList(in *appsv1beta1.DeploymentList, out *apps.DeploymentList, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentList_To_apps_DeploymentList(in, out, s)
}

func autoConvert_apps_DeploymentList_To_v1beta1_DeploymentList(in *apps.DeploymentList, out *appsv1beta1.DeploymentList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1beta1.Deployment, len(*in))
                for i := range *in {
                        if err := Convert_apps_Deployment_To_v1beta1_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_DeploymentList_To_v1beta1_DeploymentList is an autogenerated conversion function.
func Convert_apps_DeploymentList_To_v1beta1_DeploymentList(in *apps.DeploymentList, out *appsv1beta1.DeploymentList, s conversion.Scope) error {
        return autoConvert_apps_DeploymentList_To_v1beta1_DeploymentList(in, out, s)
}

func autoConvert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback(in *appsv1beta1.DeploymentRollback, out *apps.DeploymentRollback, s conversion.Scope) error {
        out.Name = in.Name
        out.UpdatedAnnotations = *(*map[string]string)(unsafe.Pointer(&in.UpdatedAnnotations))
        if err := Convert_v1beta1_RollbackConfig_To_apps_RollbackConfig(&in.RollbackTo, &out.RollbackTo, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback is an autogenerated conversion function.
func Convert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback(in *appsv1beta1.DeploymentRollback, out *apps.DeploymentRollback, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback(in, out, s)
}

func autoConvert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback(in *apps.DeploymentRollback, out *appsv1beta1.DeploymentRollback, s conversion.Scope) error {
        out.Name = in.Name
        out.UpdatedAnnotations = *(*map[string]string)(unsafe.Pointer(&in.UpdatedAnnotations))
        if err := Convert_apps_RollbackConfig_To_v1beta1_RollbackConfig(&in.RollbackTo, &out.RollbackTo, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback is an autogenerated conversion function.
func Convert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback(in *apps.DeploymentRollback, out *appsv1beta1.DeploymentRollback, s conversion.Scope) error {
        return autoConvert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback(in, out, s)
}

func autoConvert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(in *appsv1beta1.DeploymentSpec, out *apps.DeploymentSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.Paused = in.Paused
        out.RollbackTo = (*apps.RollbackConfig)(unsafe.Pointer(in.RollbackTo))
        out.ProgressDeadlineSeconds = (*int32)(unsafe.Pointer(in.ProgressDeadlineSeconds))
        return nil
}

// Convert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec is an autogenerated conversion function.
func Convert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(in *appsv1beta1.DeploymentSpec, out *apps.DeploymentSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(in, out, s)
}

func autoConvert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(in *apps.DeploymentSpec, out *appsv1beta1.DeploymentSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.Paused = in.Paused
        out.RollbackTo = (*appsv1beta1.RollbackConfig)(unsafe.Pointer(in.RollbackTo))
        out.ProgressDeadlineSeconds = (*int32)(unsafe.Pointer(in.ProgressDeadlineSeconds))
        return nil
}

// Convert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec is an autogenerated conversion function.
func Convert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(in *apps.DeploymentSpec, out *appsv1beta1.DeploymentSpec, s conversion.Scope) error {
        return autoConvert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(in, out, s)
}

func autoConvert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(in *appsv1beta1.DeploymentStatus, out *apps.DeploymentStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Replicas = in.Replicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.UnavailableReplicas = in.UnavailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.Conditions = *(*[]apps.DeploymentCondition)(unsafe.Pointer(&in.Conditions))
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        return nil
}

// Convert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus is an autogenerated conversion function.
func Convert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(in *appsv1beta1.DeploymentStatus, out *apps.DeploymentStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(in, out, s)
}

func autoConvert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(in *apps.DeploymentStatus, out *appsv1beta1.DeploymentStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Replicas = in.Replicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.UnavailableReplicas = in.UnavailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.Conditions = *(*[]appsv1beta1.DeploymentCondition)(unsafe.Pointer(&in.Conditions))
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        return nil
}

// Convert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus is an autogenerated conversion function.
func Convert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(in *apps.DeploymentStatus, out *appsv1beta1.DeploymentStatus, s conversion.Scope) error {
        return autoConvert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(in, out, s)
}

func autoConvert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(in *appsv1beta1.DeploymentStrategy, out *apps.DeploymentStrategy, s conversion.Scope) error {
        out.Type = apps.DeploymentStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateDeployment)
                if err := Convert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy is an autogenerated conversion function.
func Convert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(in *appsv1beta1.DeploymentStrategy, out *apps.DeploymentStrategy, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(in, out, s)
}

func autoConvert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in *apps.DeploymentStrategy, out *appsv1beta1.DeploymentStrategy, s conversion.Scope) error {
        out.Type = appsv1beta1.DeploymentStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(appsv1beta1.RollingUpdateDeployment)
                if err := Convert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy is an autogenerated conversion function.
func Convert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in *apps.DeploymentStrategy, out *appsv1beta1.DeploymentStrategy, s conversion.Scope) error {
        return autoConvert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in, out, s)
}

func autoConvert_v1beta1_RollbackConfig_To_apps_RollbackConfig(in *appsv1beta1.RollbackConfig, out *apps.RollbackConfig, s conversion.Scope) error {
        out.Revision = in.Revision
        return nil
}

// Convert_v1beta1_RollbackConfig_To_apps_RollbackConfig is an autogenerated conversion function.
func Convert_v1beta1_RollbackConfig_To_apps_RollbackConfig(in *appsv1beta1.RollbackConfig, out *apps.RollbackConfig, s conversion.Scope) error {
        return autoConvert_v1beta1_RollbackConfig_To_apps_RollbackConfig(in, out, s)
}

func autoConvert_apps_RollbackConfig_To_v1beta1_RollbackConfig(in *apps.RollbackConfig, out *appsv1beta1.RollbackConfig, s conversion.Scope) error {
        out.Revision = in.Revision
        return nil
}

// Convert_apps_RollbackConfig_To_v1beta1_RollbackConfig is an autogenerated conversion function.
func Convert_apps_RollbackConfig_To_v1beta1_RollbackConfig(in *apps.RollbackConfig, out *appsv1beta1.RollbackConfig, s conversion.Scope) error {
        return autoConvert_apps_RollbackConfig_To_v1beta1_RollbackConfig(in, out, s)
}

func autoConvert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in *appsv1beta1.RollingUpdateDeployment, out *apps.RollingUpdateDeployment, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment is an autogenerated conversion function.
func Convert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in *appsv1beta1.RollingUpdateDeployment, out *apps.RollingUpdateDeployment, s conversion.Scope) error {
        return autoConvert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in, out, s)
}

func autoConvert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in *apps.RollingUpdateDeployment, out *appsv1beta1.RollingUpdateDeployment, s conversion.Scope) error {
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment is an autogenerated conversion function.
func Convert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in *apps.RollingUpdateDeployment, out *appsv1beta1.RollingUpdateDeployment, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in, out, s)
}

func autoConvert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *appsv1beta1.RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Partition, &out.Partition, s); err != nil {
                return err
        }
        out.MaxUnavailable = (*intstr.IntOrString)(unsafe.Pointer(in.MaxUnavailable))
        return nil
}

// Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
func Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *appsv1beta1.RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        return autoConvert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in, out, s)
}

func autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *appsv1beta1.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Partition, &out.Partition, s); err != nil {
                return err
        }
        out.MaxUnavailable = (*intstr.IntOrString)(unsafe.Pointer(in.MaxUnavailable))
        return nil
}

// Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
func Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *appsv1beta1.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(in, out, s)
}

func autoConvert_v1beta1_Scale_To_autoscaling_Scale(in *appsv1beta1.Scale, out *autoscaling.Scale, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_Scale_To_autoscaling_Scale is an autogenerated conversion function.
func Convert_v1beta1_Scale_To_autoscaling_Scale(in *appsv1beta1.Scale, out *autoscaling.Scale, s conversion.Scope) error {
        return autoConvert_v1beta1_Scale_To_autoscaling_Scale(in, out, s)
}

func autoConvert_autoscaling_Scale_To_v1beta1_Scale(in *autoscaling.Scale, out *appsv1beta1.Scale, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_Scale_To_v1beta1_Scale is an autogenerated conversion function.
func Convert_autoscaling_Scale_To_v1beta1_Scale(in *autoscaling.Scale, out *appsv1beta1.Scale, s conversion.Scope) error {
        return autoConvert_autoscaling_Scale_To_v1beta1_Scale(in, out, s)
}

func autoConvert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(in *appsv1beta1.ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
        out.Replicas = in.Replicas
        return nil
}

// Convert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec is an autogenerated conversion function.
func Convert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(in *appsv1beta1.ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(in, out, s)
}

func autoConvert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(in *autoscaling.ScaleSpec, out *appsv1beta1.ScaleSpec, s conversion.Scope) error {
        out.Replicas = in.Replicas
        return nil
}

// Convert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec is an autogenerated conversion function.
func Convert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(in *autoscaling.ScaleSpec, out *appsv1beta1.ScaleSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(in, out, s)
}

func autoConvert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(in *appsv1beta1.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        // WARNING: in.Selector requires manual conversion: inconvertible types (map[string]string vs string)
        // WARNING: in.TargetSelector requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(in *autoscaling.ScaleStatus, out *appsv1beta1.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        // WARNING: in.Selector requires manual conversion: inconvertible types (string vs map[string]string)
        return nil
}

func autoConvert_v1beta1_StatefulSet_To_apps_StatefulSet(in *appsv1beta1.StatefulSet, out *apps.StatefulSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_StatefulSetSpec_To_apps_StatefulSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_StatefulSetStatus_To_apps_StatefulSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_StatefulSet_To_apps_StatefulSet is an autogenerated conversion function.
func Convert_v1beta1_StatefulSet_To_apps_StatefulSet(in *appsv1beta1.StatefulSet, out *apps.StatefulSet, s conversion.Scope) error {
        return autoConvert_v1beta1_StatefulSet_To_apps_StatefulSet(in, out, s)
}

func autoConvert_apps_StatefulSet_To_v1beta1_StatefulSet(in *apps.StatefulSet, out *appsv1beta1.StatefulSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_StatefulSetSpec_To_v1beta1_StatefulSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_StatefulSetStatus_To_v1beta1_StatefulSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_StatefulSet_To_v1beta1_StatefulSet is an autogenerated conversion function.
func Convert_apps_StatefulSet_To_v1beta1_StatefulSet(in *apps.StatefulSet, out *appsv1beta1.StatefulSet, s conversion.Scope) error {
        return autoConvert_apps_StatefulSet_To_v1beta1_StatefulSet(in, out, s)
}

func autoConvert_v1beta1_StatefulSetCondition_To_apps_StatefulSetCondition(in *appsv1beta1.StatefulSetCondition, out *apps.StatefulSetCondition, s conversion.Scope) error {
        out.Type = apps.StatefulSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta1_StatefulSetCondition_To_apps_StatefulSetCondition is an autogenerated conversion function.
func Convert_v1beta1_StatefulSetCondition_To_apps_StatefulSetCondition(in *appsv1beta1.StatefulSetCondition, out *apps.StatefulSetCondition, s conversion.Scope) error {
        return autoConvert_v1beta1_StatefulSetCondition_To_apps_StatefulSetCondition(in, out, s)
}

func autoConvert_apps_StatefulSetCondition_To_v1beta1_StatefulSetCondition(in *apps.StatefulSetCondition, out *appsv1beta1.StatefulSetCondition, s conversion.Scope) error {
        out.Type = appsv1beta1.StatefulSetConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_StatefulSetCondition_To_v1beta1_StatefulSetCondition is an autogenerated conversion function.
func Convert_apps_StatefulSetCondition_To_v1beta1_StatefulSetCondition(in *apps.StatefulSetCondition, out *appsv1beta1.StatefulSetCondition, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetCondition_To_v1beta1_StatefulSetCondition(in, out, s)
}

func autoConvert_v1beta1_StatefulSetList_To_apps_StatefulSetList(in *appsv1beta1.StatefulSetList, out *apps.StatefulSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.StatefulSet, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_StatefulSet_To_apps_StatefulSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_StatefulSetList_To_apps_StatefulSetList is an autogenerated conversion function.
func Convert_v1beta1_StatefulSetList_To_apps_StatefulSetList(in *appsv1beta1.StatefulSetList, out *apps.StatefulSetList, s conversion.Scope) error {
        return autoConvert_v1beta1_StatefulSetList_To_apps_StatefulSetList(in, out, s)
}

func autoConvert_apps_StatefulSetList_To_v1beta1_StatefulSetList(in *apps.StatefulSetList, out *appsv1beta1.StatefulSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1beta1.StatefulSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_StatefulSet_To_v1beta1_StatefulSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_StatefulSetList_To_v1beta1_StatefulSetList is an autogenerated conversion function.
func Convert_apps_StatefulSetList_To_v1beta1_StatefulSetList(in *apps.StatefulSetList, out *appsv1beta1.StatefulSetList, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetList_To_v1beta1_StatefulSetList(in, out, s)
}

func autoConvert_v1beta1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in *appsv1beta1.StatefulSetOrdinals, out *apps.StatefulSetOrdinals, s conversion.Scope) error {
        out.Start = in.Start
        return nil
}

// Convert_v1beta1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals is an autogenerated conversion function.
func Convert_v1beta1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in *appsv1beta1.StatefulSetOrdinals, out *apps.StatefulSetOrdinals, s conversion.Scope) error {
        return autoConvert_v1beta1_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in, out, s)
}

func autoConvert_apps_StatefulSetOrdinals_To_v1beta1_StatefulSetOrdinals(in *apps.StatefulSetOrdinals, out *appsv1beta1.StatefulSetOrdinals, s conversion.Scope) error {
        out.Start = in.Start
        return nil
}

// Convert_apps_StatefulSetOrdinals_To_v1beta1_StatefulSetOrdinals is an autogenerated conversion function.
func Convert_apps_StatefulSetOrdinals_To_v1beta1_StatefulSetOrdinals(in *apps.StatefulSetOrdinals, out *appsv1beta1.StatefulSetOrdinals, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetOrdinals_To_v1beta1_StatefulSetOrdinals(in, out, s)
}

func autoConvert_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in *appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy, out *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        out.WhenDeleted = apps.PersistentVolumeClaimRetentionPolicyType(in.WhenDeleted)
        out.WhenScaled = apps.PersistentVolumeClaimRetentionPolicyType(in.WhenScaled)
        return nil
}

// Convert_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy is an autogenerated conversion function.
func Convert_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in *appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy, out *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        return autoConvert_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in, out, s)
}

func autoConvert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy(in *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, out *appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        out.WhenDeleted = appsv1beta1.PersistentVolumeClaimRetentionPolicyType(in.WhenDeleted)
        out.WhenScaled = appsv1beta1.PersistentVolumeClaimRetentionPolicyType(in.WhenScaled)
        return nil
}

// Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy is an autogenerated conversion function.
func Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy(in *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, out *appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta1_StatefulSetPersistentVolumeClaimRetentionPolicy(in, out, s)
}

func autoConvert_v1beta1_StatefulSetSpec_To_apps_StatefulSetSpec(in *appsv1beta1.StatefulSetSpec, out *apps.StatefulSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        out.VolumeClaimTemplates = *(*[]core.PersistentVolumeClaim)(unsafe.Pointer(&in.VolumeClaimTemplates))
        out.ServiceName = in.ServiceName
        out.PodManagementPolicy = apps.PodManagementPolicyType(in.PodManagementPolicy)
        if err := Convert_v1beta1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.MinReadySeconds = in.MinReadySeconds
        out.PersistentVolumeClaimRetentionPolicy = (*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(unsafe.Pointer(in.PersistentVolumeClaimRetentionPolicy))
        out.Ordinals = (*apps.StatefulSetOrdinals)(unsafe.Pointer(in.Ordinals))
        return nil
}

func autoConvert_apps_StatefulSetSpec_To_v1beta1_StatefulSetSpec(in *apps.StatefulSetSpec, out *appsv1beta1.StatefulSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        out.VolumeClaimTemplates = *(*[]v1.PersistentVolumeClaim)(unsafe.Pointer(&in.VolumeClaimTemplates))
        out.ServiceName = in.ServiceName
        out.PodManagementPolicy = appsv1beta1.PodManagementPolicyType(in.PodManagementPolicy)
        if err := Convert_apps_StatefulSetUpdateStrategy_To_v1beta1_StatefulSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.MinReadySeconds = in.MinReadySeconds
        out.PersistentVolumeClaimRetentionPolicy = (*appsv1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy)(unsafe.Pointer(in.PersistentVolumeClaimRetentionPolicy))
        out.Ordinals = (*appsv1beta1.StatefulSetOrdinals)(unsafe.Pointer(in.Ordinals))
        return nil
}

func autoConvert_v1beta1_StatefulSetStatus_To_apps_StatefulSetStatus(in *appsv1beta1.StatefulSetStatus, out *apps.StatefulSetStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.Replicas = in.Replicas
        out.ReadyReplicas = in.ReadyReplicas
        out.CurrentReplicas = in.CurrentReplicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.CurrentRevision = in.CurrentRevision
        out.UpdateRevision = in.UpdateRevision
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]apps.StatefulSetCondition)(unsafe.Pointer(&in.Conditions))
        out.AvailableReplicas = in.AvailableReplicas
        return nil
}

// Convert_v1beta1_StatefulSetStatus_To_apps_StatefulSetStatus is an autogenerated conversion function.
func Convert_v1beta1_StatefulSetStatus_To_apps_StatefulSetStatus(in *appsv1beta1.StatefulSetStatus, out *apps.StatefulSetStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_StatefulSetStatus_To_apps_StatefulSetStatus(in, out, s)
}

func autoConvert_apps_StatefulSetStatus_To_v1beta1_StatefulSetStatus(in *apps.StatefulSetStatus, out *appsv1beta1.StatefulSetStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.Replicas = in.Replicas
        out.ReadyReplicas = in.ReadyReplicas
        out.CurrentReplicas = in.CurrentReplicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.CurrentRevision = in.CurrentRevision
        out.UpdateRevision = in.UpdateRevision
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]appsv1beta1.StatefulSetCondition)(unsafe.Pointer(&in.Conditions))
        out.AvailableReplicas = in.AvailableReplicas
        return nil
}

// Convert_apps_StatefulSetStatus_To_v1beta1_StatefulSetStatus is an autogenerated conversion function.
func Convert_apps_StatefulSetStatus_To_v1beta1_StatefulSetStatus(in *apps.StatefulSetStatus, out *appsv1beta1.StatefulSetStatus, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetStatus_To_v1beta1_StatefulSetStatus(in, out, s)
}

func autoConvert_v1beta1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in *appsv1beta1.StatefulSetUpdateStrategy, out *apps.StatefulSetUpdateStrategy, s conversion.Scope) error {
        out.Type = apps.StatefulSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateStatefulSetStrategy)
                if err := Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1beta1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy is an autogenerated conversion function.
func Convert_v1beta1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in *appsv1beta1.StatefulSetUpdateStrategy, out *apps.StatefulSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_v1beta1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in, out, s)
}

func autoConvert_apps_StatefulSetUpdateStrategy_To_v1beta1_StatefulSetUpdateStrategy(in *apps.StatefulSetUpdateStrategy, out *appsv1beta1.StatefulSetUpdateStrategy, s conversion.Scope) error {
        out.Type = appsv1beta1.StatefulSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(appsv1beta1.RollingUpdateStatefulSetStrategy)
                if err := Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_StatefulSetUpdateStrategy_To_v1beta1_StatefulSetUpdateStrategy is an autogenerated conversion function.
func Convert_apps_StatefulSetUpdateStrategy_To_v1beta1_StatefulSetUpdateStrategy(in *apps.StatefulSetUpdateStrategy, out *appsv1beta1.StatefulSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetUpdateStrategy_To_v1beta1_StatefulSetUpdateStrategy(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        appsv1beta1 "k8s.io/api/apps/v1beta1"
        v1 "k8s.io/api/core/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&appsv1beta1.Deployment{}, func(obj interface{}) { SetObjectDefaults_Deployment(obj.(*appsv1beta1.Deployment)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta1.DeploymentList{}, func(obj interface{}) { SetObjectDefaults_DeploymentList(obj.(*appsv1beta1.DeploymentList)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta1.StatefulSet{}, func(obj interface{}) { SetObjectDefaults_StatefulSet(obj.(*appsv1beta1.StatefulSet)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta1.StatefulSetList{}, func(obj interface{}) { SetObjectDefaults_StatefulSetList(obj.(*appsv1beta1.StatefulSetList)) })
        return nil
}

func SetObjectDefaults_Deployment(in *appsv1beta1.Deployment) {
        SetDefaults_Deployment(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_DeploymentList(in *appsv1beta1.DeploymentList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Deployment(a)
        }
}

func SetObjectDefaults_StatefulSet(in *appsv1beta1.StatefulSet) {
        SetDefaults_StatefulSet(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
        for i := range in.Spec.VolumeClaimTemplates {
                a := &in.Spec.VolumeClaimTemplates[i]
                corev1.SetDefaults_PersistentVolumeClaim(a)
                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.Spec)
                corev1.SetDefaults_ResourceList(&a.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Spec.Resources.Requests)
                corev1.SetDefaults_ResourceList(&a.Status.Capacity)
                corev1.SetDefaults_ResourceList(&a.Status.AllocatedResources)
        }
}

func SetObjectDefaults_StatefulSetList(in *appsv1beta1.StatefulSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_StatefulSet(a)
        }
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 validation-gen. DO NOT EDIT.

package v1beta1

import (
        context "context"
        fmt "fmt"

        appsv1beta1 "k8s.io/api/apps/v1beta1"
        operation "k8s.io/apimachinery/pkg/api/operation"
        safe "k8s.io/apimachinery/pkg/api/safe"
        validate "k8s.io/apimachinery/pkg/api/validate"
        runtime "k8s.io/apimachinery/pkg/runtime"
        field "k8s.io/apimachinery/pkg/util/validation/field"
)

func init() { localSchemeBuilder.Register(RegisterValidations) }

// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
        scheme.AddValidationFunc((*appsv1beta1.Scale)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/scale":
                        return Validate_Scale(ctx, op, nil /* fldPath */, obj.(*appsv1beta1.Scale), safe.Cast[*appsv1beta1.Scale](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        return nil
}

func Validate_Scale(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *appsv1beta1.Scale) (errs field.ErrorList) {
        // field appsv1beta1.Scale.TypeMeta has no validation
        // field appsv1beta1.Scale.ObjectMeta has no validation

        // field appsv1beta1.Scale.Spec
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *appsv1beta1.ScaleSpec) (errs field.ErrorList) {
                        errs = append(errs, Validate_ScaleSpec(ctx, op, fldPath, obj, oldObj)...)
                        return
                }(fldPath.Child("spec"), &obj.Spec, safe.Field(oldObj, func(oldObj *appsv1beta1.Scale) *appsv1beta1.ScaleSpec { return &oldObj.Spec }))...)

        // field appsv1beta1.Scale.Status has no validation
        return errs
}

func Validate_ScaleSpec(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *appsv1beta1.ScaleSpec) (errs field.ErrorList) {
        // field appsv1beta1.ScaleSpec.Replicas
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *int32) (errs field.ErrorList) {
                        // optional value-type fields with zero-value defaults are purely documentation
                        if op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
                                return nil // no changes
                        }
                        errs = append(errs, validate.Minimum(ctx, op, fldPath, obj, oldObj, 0)...)
                        return
                }(fldPath.Child("replicas"), &obj.Replicas, safe.Field(oldObj, func(oldObj *appsv1beta1.ScaleSpec) *int32 { return &oldObj.Replicas }))...)

        return errs
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1beta2

import (
        "fmt"
        "strconv"

        appsv1beta2 "k8s.io/api/apps/v1beta2"
        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/kubernetes/pkg/apis/apps"
        autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/kubernetes/pkg/apis/core"
)

func addConversionFuncs(scheme *runtime.Scheme) error {
        // Add field label conversions for kinds having selectable nothing but ObjectMeta fields.
        if err := scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("StatefulSet"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name", "metadata.namespace", "status.successful":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported for appsv1beta2.StatefulSet: %s", label)
                        }
                }); err != nil {
                return err
        }

        return nil
}

func Convert_autoscaling_ScaleStatus_To_v1beta2_ScaleStatus(in *autoscaling.ScaleStatus, out *appsv1beta2.ScaleStatus, s conversion.Scope) error {
        out.Replicas = int32(in.Replicas)
        out.TargetSelector = in.Selector

        out.Selector = nil
        selector, err := metav1.ParseToLabelSelector(in.Selector)
        if err != nil {
                return fmt.Errorf("failed to parse selector: %v", err)
        }
        if len(selector.MatchExpressions) == 0 {
                out.Selector = selector.MatchLabels
        }

        return nil
}

func Convert_v1beta2_ScaleStatus_To_autoscaling_ScaleStatus(in *appsv1beta2.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas

        // Normally when 2 fields map to the same internal value we favor the old field, since
        // old clients can't be expected to know about new fields but clients that know about the
        // new field can be expected to know about the old field (though that's not quite true, due
        // to kubectl apply). However, these fields are readonly, so any non-nil value should work.
        if in.TargetSelector != "" {
                out.Selector = in.TargetSelector
        } else if in.Selector != nil {
                set := labels.Set{}
                for key, val := range in.Selector {
                        set[key] = val
                }
                out.Selector = labels.SelectorFromSet(set).String()
        } else {
                out.Selector = ""
        }
        return nil
}

// Convert_apps_DeploymentSpec_To_v1beta2_DeploymentSpec is defined here, because public
// conversion is not auto-generated due to existing warnings.
func Convert_apps_DeploymentSpec_To_v1beta2_DeploymentSpec(in *apps.DeploymentSpec, out *appsv1beta2.DeploymentSpec, s conversion.Scope) error {
        if err := autoConvert_apps_DeploymentSpec_To_v1beta2_DeploymentSpec(in, out, s); err != nil {
                return err
        }
        return nil
}

func Convert_v1beta2_Deployment_To_apps_Deployment(in *appsv1beta2.Deployment, out *apps.Deployment, s conversion.Scope) error {
        if err := autoConvert_v1beta2_Deployment_To_apps_Deployment(in, out, s); err != nil {
                return err
        }

        // Copy annotation to deprecated rollbackTo field for roundtrip
        // TODO: remove this conversion after we delete extensions/v1beta1 and apps/v1beta1 Deployment
        if revision := in.Annotations[appsv1beta2.DeprecatedRollbackTo]; revision != "" {
                if revision64, err := strconv.ParseInt(revision, 10, 64); err != nil {
                        return fmt.Errorf("failed to parse annotation[%s]=%s as int64: %v", appsv1beta2.DeprecatedRollbackTo, revision, err)
                } else {
                        out.Spec.RollbackTo = new(apps.RollbackConfig)
                        out.Spec.RollbackTo.Revision = revision64
                }
                out.Annotations = deepCopyStringMap(out.Annotations)
                delete(out.Annotations, appsv1beta2.DeprecatedRollbackTo)
        } else {
                out.Spec.RollbackTo = nil
        }

        return nil
}

func Convert_apps_Deployment_To_v1beta2_Deployment(in *apps.Deployment, out *appsv1beta2.Deployment, s conversion.Scope) error {
        if err := autoConvert_apps_Deployment_To_v1beta2_Deployment(in, out, s); err != nil {
                return err
        }

        out.Annotations = deepCopyStringMap(out.Annotations) // deep copy because we modify annotations below
        // Copy deprecated rollbackTo field to annotation for roundtrip
        // TODO: remove this conversion after we delete extensions/v1beta1 and apps/v1beta1 Deployment
        if in.Spec.RollbackTo != nil {
                if out.Annotations == nil {
                        out.Annotations = make(map[string]string)
                }
                out.Annotations[appsv1beta2.DeprecatedRollbackTo] = strconv.FormatInt(in.Spec.RollbackTo.Revision, 10)
        } else {
                delete(out.Annotations, appsv1beta2.DeprecatedRollbackTo)
        }

        return nil
}

func Convert_apps_DaemonSet_To_v1beta2_DaemonSet(in *apps.DaemonSet, out *appsv1beta2.DaemonSet, s conversion.Scope) error {
        if err := autoConvert_apps_DaemonSet_To_v1beta2_DaemonSet(in, out, s); err != nil {
                return err
        }

        out.Annotations = deepCopyStringMap(out.Annotations)
        out.Annotations[appsv1beta2.DeprecatedTemplateGeneration] = strconv.FormatInt(in.Spec.TemplateGeneration, 10)
        return nil
}

// Convert_apps_DaemonSetSpec_To_v1beta2_DaemonSetSpec is defined here, because public
// conversion is not auto-generated due to existing warnings.
func Convert_apps_DaemonSetSpec_To_v1beta2_DaemonSetSpec(in *apps.DaemonSetSpec, out *appsv1beta2.DaemonSetSpec, s conversion.Scope) error {
        if err := autoConvert_apps_DaemonSetSpec_To_v1beta2_DaemonSetSpec(in, out, s); err != nil {
                return err
        }
        return nil
}

func Convert_v1beta2_DaemonSet_To_apps_DaemonSet(in *appsv1beta2.DaemonSet, out *apps.DaemonSet, s conversion.Scope) error {
        if err := autoConvert_v1beta2_DaemonSet_To_apps_DaemonSet(in, out, s); err != nil {
                return err
        }

        if value, ok := in.Annotations[appsv1beta2.DeprecatedTemplateGeneration]; ok {
                if value64, err := strconv.ParseInt(value, 10, 64); err != nil {
                        return err
                } else {
                        out.Spec.TemplateGeneration = value64
                        out.Annotations = deepCopyStringMap(out.Annotations)
                        delete(out.Annotations, appsv1beta2.DeprecatedTemplateGeneration)
                }
        }

        return nil
}

func deepCopyStringMap(m map[string]string) map[string]string {
        ret := make(map[string]string, len(m))
        for k, v := range m {
                ret[k] = v
        }
        return ret
}

// Convert_v1beta2_StatefulSetSpec_To_apps_StatefulSetSpec augments auto-conversion to preserve < 1.17 behavior
// setting apiVersion/kind in nested persistent volume claim objects.
func Convert_v1beta2_StatefulSetSpec_To_apps_StatefulSetSpec(in *appsv1beta2.StatefulSetSpec, out *apps.StatefulSetSpec, s conversion.Scope) error {
        if err := autoConvert_v1beta2_StatefulSetSpec_To_apps_StatefulSetSpec(in, out, s); err != nil {
                return err
        }
        // set APIVersion/Kind to behave the same as reflective conversion < 1.17.
        // see https://issue.k8s.io/87583
        if out.VolumeClaimTemplates != nil {
                // copy so we don't modify the input
                templatesCopy := make([]core.PersistentVolumeClaim, len(out.VolumeClaimTemplates))
                copy(templatesCopy, out.VolumeClaimTemplates)
                out.VolumeClaimTemplates = templatesCopy
                for i := range out.VolumeClaimTemplates {
                        out.VolumeClaimTemplates[i].APIVersion = ""
                        out.VolumeClaimTemplates[i].Kind = ""
                }
        }
        return nil
}

// Convert_apps_StatefulSetSpec_To_v1beta2_StatefulSetSpec augments auto-conversion to preserve < 1.17 behavior
// setting apiVersion/kind in nested persistent volume claim objects.
func Convert_apps_StatefulSetSpec_To_v1beta2_StatefulSetSpec(in *apps.StatefulSetSpec, out *appsv1beta2.StatefulSetSpec, s conversion.Scope) error {
        if err := autoConvert_apps_StatefulSetSpec_To_v1beta2_StatefulSetSpec(in, out, s); err != nil {
                return err
        }
        // set APIVersion/Kind to behave the same as reflective conversion < 1.17.
        // see https://issue.k8s.io/87583
        if out.VolumeClaimTemplates != nil {
                // copy so we don't modify the input
                templatesCopy := make([]corev1.PersistentVolumeClaim, len(out.VolumeClaimTemplates))
                copy(templatesCopy, out.VolumeClaimTemplates)
                out.VolumeClaimTemplates = templatesCopy
                for i := range out.VolumeClaimTemplates {
                        out.VolumeClaimTemplates[i].APIVersion = "v1"
                        out.VolumeClaimTemplates[i].Kind = "PersistentVolumeClaim"
                }
        }
        return nil
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1beta2

import (
        appsv1beta2 "k8s.io/api/apps/v1beta2"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/util/intstr"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        "k8s.io/kubernetes/pkg/features"
        "k8s.io/utils/ptr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_DaemonSet(obj *appsv1beta2.DaemonSet) {
        updateStrategy := &obj.Spec.UpdateStrategy
        if updateStrategy.Type == "" {
                updateStrategy.Type = appsv1beta2.RollingUpdateDaemonSetStrategyType
        }
        if updateStrategy.Type == appsv1beta2.RollingUpdateDaemonSetStrategyType {
                if updateStrategy.RollingUpdate == nil {
                        rollingUpdate := appsv1beta2.RollingUpdateDaemonSet{}
                        updateStrategy.RollingUpdate = &rollingUpdate
                }
                if updateStrategy.RollingUpdate.MaxUnavailable == nil {
                        // Set default MaxUnavailable as 1 by default.
                        updateStrategy.RollingUpdate.MaxUnavailable = ptr.To(intstr.FromInt32(1))
                }
                if updateStrategy.RollingUpdate.MaxSurge == nil {
                        // Set default MaxSurge as 0 by default.
                        updateStrategy.RollingUpdate.MaxSurge = ptr.To(intstr.FromInt32(0))
                }
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 10
        }
}

func SetDefaults_StatefulSet(obj *appsv1beta2.StatefulSet) {
        if len(obj.Spec.PodManagementPolicy) == 0 {
                obj.Spec.PodManagementPolicy = appsv1beta2.OrderedReadyPodManagement
        }

        if obj.Spec.UpdateStrategy.Type == "" {
                obj.Spec.UpdateStrategy.Type = appsv1beta2.RollingUpdateStatefulSetStrategyType

                if obj.Spec.UpdateStrategy.RollingUpdate == nil {
                        // UpdateStrategy.RollingUpdate will take default values below.
                        obj.Spec.UpdateStrategy.RollingUpdate = &appsv1beta2.RollingUpdateStatefulSetStrategy{}
                }
        }

        if obj.Spec.UpdateStrategy.Type == appsv1beta2.RollingUpdateStatefulSetStrategyType &&
                obj.Spec.UpdateStrategy.RollingUpdate != nil {

                if obj.Spec.UpdateStrategy.RollingUpdate.Partition == nil {
                        obj.Spec.UpdateStrategy.RollingUpdate.Partition = ptr.To[int32](0)
                }
                if utilfeature.DefaultFeatureGate.Enabled(features.MaxUnavailableStatefulSet) {
                        if obj.Spec.UpdateStrategy.RollingUpdate.MaxUnavailable == nil {
                                obj.Spec.UpdateStrategy.RollingUpdate.MaxUnavailable = ptr.To(intstr.FromInt32(1))
                        }
                }
        }

        if obj.Spec.PersistentVolumeClaimRetentionPolicy == nil {
                obj.Spec.PersistentVolumeClaimRetentionPolicy = &appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy{}
        }
        if len(obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenDeleted) == 0 {
                obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenDeleted = appsv1beta2.RetainPersistentVolumeClaimRetentionPolicyType
        }
        if len(obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenScaled) == 0 {
                obj.Spec.PersistentVolumeClaimRetentionPolicy.WhenScaled = appsv1beta2.RetainPersistentVolumeClaimRetentionPolicyType
        }

        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 10
        }
}

// SetDefaults_Deployment sets additional defaults compared to its counterpart
// in extensions. These addons are:
// - MaxUnavailable during rolling update set to 25% (1 in extensions)
// - MaxSurge value during rolling update set to 25% (1 in extensions)
// - RevisionHistoryLimit set to 10 (not set in extensions)
// - ProgressDeadlineSeconds set to 600s (not set in extensions)
func SetDefaults_Deployment(obj *appsv1beta2.Deployment) {
        // Set appsv1beta2.DeploymentSpec.Replicas to 1 if it is not set.
        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
        strategy := &obj.Spec.Strategy
        // Set default appsv1beta2.DeploymentStrategyType as RollingUpdate.
        if strategy.Type == "" {
                strategy.Type = appsv1beta2.RollingUpdateDeploymentStrategyType
        }
        if strategy.Type == appsv1beta2.RollingUpdateDeploymentStrategyType {
                if strategy.RollingUpdate == nil {
                        rollingUpdate := appsv1beta2.RollingUpdateDeployment{}
                        strategy.RollingUpdate = &rollingUpdate
                }
                if strategy.RollingUpdate.MaxUnavailable == nil {
                        // Set default MaxUnavailable as 25% by default.
                        maxUnavailable := intstr.FromString("25%")
                        strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
                }
                if strategy.RollingUpdate.MaxSurge == nil {
                        // Set default MaxSurge as 25% by default.
                        maxSurge := intstr.FromString("25%")
                        strategy.RollingUpdate.MaxSurge = &maxSurge
                }
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 10
        }
        if obj.Spec.ProgressDeadlineSeconds == nil {
                obj.Spec.ProgressDeadlineSeconds = new(int32)
                *obj.Spec.ProgressDeadlineSeconds = 600
        }
}

func SetDefaults_ReplicaSet(obj *appsv1beta2.ReplicaSet) {
        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1beta2

import (
        appsv1beta2 "k8s.io/api/apps/v1beta2"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "apps"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta2"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &appsv1beta2.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta2

import (
        unsafe "unsafe"

        appsv1beta2 "k8s.io/api/apps/v1beta2"
        v1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        intstr "k8s.io/apimachinery/pkg/util/intstr"
        apps "k8s.io/kubernetes/pkg/apis/apps"
        autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
        core "k8s.io/kubernetes/pkg/apis/core"
        corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.ControllerRevision)(nil), (*apps.ControllerRevision)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ControllerRevision_To_apps_ControllerRevision(a.(*appsv1beta2.ControllerRevision), b.(*apps.ControllerRevision), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ControllerRevision)(nil), (*appsv1beta2.ControllerRevision)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ControllerRevision_To_v1beta2_ControllerRevision(a.(*apps.ControllerRevision), b.(*appsv1beta2.ControllerRevision), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.ControllerRevisionList)(nil), (*apps.ControllerRevisionList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ControllerRevisionList_To_apps_ControllerRevisionList(a.(*appsv1beta2.ControllerRevisionList), b.(*apps.ControllerRevisionList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ControllerRevisionList)(nil), (*appsv1beta2.ControllerRevisionList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ControllerRevisionList_To_v1beta2_ControllerRevisionList(a.(*apps.ControllerRevisionList), b.(*appsv1beta2.ControllerRevisionList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DaemonSetCondition)(nil), (*apps.DaemonSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DaemonSetCondition_To_apps_DaemonSetCondition(a.(*appsv1beta2.DaemonSetCondition), b.(*apps.DaemonSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetCondition)(nil), (*appsv1beta2.DaemonSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetCondition_To_v1beta2_DaemonSetCondition(a.(*apps.DaemonSetCondition), b.(*appsv1beta2.DaemonSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DaemonSetList)(nil), (*apps.DaemonSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DaemonSetList_To_apps_DaemonSetList(a.(*appsv1beta2.DaemonSetList), b.(*apps.DaemonSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetList)(nil), (*appsv1beta2.DaemonSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetList_To_v1beta2_DaemonSetList(a.(*apps.DaemonSetList), b.(*appsv1beta2.DaemonSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DaemonSetSpec)(nil), (*apps.DaemonSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DaemonSetSpec_To_apps_DaemonSetSpec(a.(*appsv1beta2.DaemonSetSpec), b.(*apps.DaemonSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DaemonSetStatus)(nil), (*apps.DaemonSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DaemonSetStatus_To_apps_DaemonSetStatus(a.(*appsv1beta2.DaemonSetStatus), b.(*apps.DaemonSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetStatus)(nil), (*appsv1beta2.DaemonSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetStatus_To_v1beta2_DaemonSetStatus(a.(*apps.DaemonSetStatus), b.(*appsv1beta2.DaemonSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DaemonSetUpdateStrategy)(nil), (*apps.DaemonSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(a.(*appsv1beta2.DaemonSetUpdateStrategy), b.(*apps.DaemonSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetUpdateStrategy)(nil), (*appsv1beta2.DaemonSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetUpdateStrategy_To_v1beta2_DaemonSetUpdateStrategy(a.(*apps.DaemonSetUpdateStrategy), b.(*appsv1beta2.DaemonSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DeploymentCondition)(nil), (*apps.DeploymentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DeploymentCondition_To_apps_DeploymentCondition(a.(*appsv1beta2.DeploymentCondition), b.(*apps.DeploymentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentCondition)(nil), (*appsv1beta2.DeploymentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentCondition_To_v1beta2_DeploymentCondition(a.(*apps.DeploymentCondition), b.(*appsv1beta2.DeploymentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DeploymentList)(nil), (*apps.DeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DeploymentList_To_apps_DeploymentList(a.(*appsv1beta2.DeploymentList), b.(*apps.DeploymentList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentList)(nil), (*appsv1beta2.DeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentList_To_v1beta2_DeploymentList(a.(*apps.DeploymentList), b.(*appsv1beta2.DeploymentList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DeploymentSpec)(nil), (*apps.DeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DeploymentSpec_To_apps_DeploymentSpec(a.(*appsv1beta2.DeploymentSpec), b.(*apps.DeploymentSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DeploymentStatus)(nil), (*apps.DeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DeploymentStatus_To_apps_DeploymentStatus(a.(*appsv1beta2.DeploymentStatus), b.(*apps.DeploymentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentStatus)(nil), (*appsv1beta2.DeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentStatus_To_v1beta2_DeploymentStatus(a.(*apps.DeploymentStatus), b.(*appsv1beta2.DeploymentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.DeploymentStrategy)(nil), (*apps.DeploymentStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DeploymentStrategy_To_apps_DeploymentStrategy(a.(*appsv1beta2.DeploymentStrategy), b.(*apps.DeploymentStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentStrategy)(nil), (*appsv1beta2.DeploymentStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentStrategy_To_v1beta2_DeploymentStrategy(a.(*apps.DeploymentStrategy), b.(*appsv1beta2.DeploymentStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.ReplicaSet)(nil), (*apps.ReplicaSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ReplicaSet_To_apps_ReplicaSet(a.(*appsv1beta2.ReplicaSet), b.(*apps.ReplicaSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSet)(nil), (*appsv1beta2.ReplicaSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSet_To_v1beta2_ReplicaSet(a.(*apps.ReplicaSet), b.(*appsv1beta2.ReplicaSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.ReplicaSetCondition)(nil), (*apps.ReplicaSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ReplicaSetCondition_To_apps_ReplicaSetCondition(a.(*appsv1beta2.ReplicaSetCondition), b.(*apps.ReplicaSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetCondition)(nil), (*appsv1beta2.ReplicaSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetCondition_To_v1beta2_ReplicaSetCondition(a.(*apps.ReplicaSetCondition), b.(*appsv1beta2.ReplicaSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.ReplicaSetList)(nil), (*apps.ReplicaSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ReplicaSetList_To_apps_ReplicaSetList(a.(*appsv1beta2.ReplicaSetList), b.(*apps.ReplicaSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetList)(nil), (*appsv1beta2.ReplicaSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetList_To_v1beta2_ReplicaSetList(a.(*apps.ReplicaSetList), b.(*appsv1beta2.ReplicaSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.ReplicaSetSpec)(nil), (*apps.ReplicaSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ReplicaSetSpec_To_apps_ReplicaSetSpec(a.(*appsv1beta2.ReplicaSetSpec), b.(*apps.ReplicaSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetSpec)(nil), (*appsv1beta2.ReplicaSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetSpec_To_v1beta2_ReplicaSetSpec(a.(*apps.ReplicaSetSpec), b.(*appsv1beta2.ReplicaSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.ReplicaSetStatus)(nil), (*apps.ReplicaSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ReplicaSetStatus_To_apps_ReplicaSetStatus(a.(*appsv1beta2.ReplicaSetStatus), b.(*apps.ReplicaSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetStatus)(nil), (*appsv1beta2.ReplicaSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetStatus_To_v1beta2_ReplicaSetStatus(a.(*apps.ReplicaSetStatus), b.(*appsv1beta2.ReplicaSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.RollingUpdateDaemonSet)(nil), (*apps.RollingUpdateDaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(a.(*appsv1beta2.RollingUpdateDaemonSet), b.(*apps.RollingUpdateDaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateDaemonSet)(nil), (*appsv1beta2.RollingUpdateDaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateDaemonSet_To_v1beta2_RollingUpdateDaemonSet(a.(*apps.RollingUpdateDaemonSet), b.(*appsv1beta2.RollingUpdateDaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.RollingUpdateDeployment)(nil), (*apps.RollingUpdateDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(a.(*appsv1beta2.RollingUpdateDeployment), b.(*apps.RollingUpdateDeployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateDeployment)(nil), (*appsv1beta2.RollingUpdateDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateDeployment_To_v1beta2_RollingUpdateDeployment(a.(*apps.RollingUpdateDeployment), b.(*appsv1beta2.RollingUpdateDeployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.RollingUpdateStatefulSetStrategy)(nil), (*apps.RollingUpdateStatefulSetStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(a.(*appsv1beta2.RollingUpdateStatefulSetStrategy), b.(*apps.RollingUpdateStatefulSetStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateStatefulSetStrategy)(nil), (*appsv1beta2.RollingUpdateStatefulSetStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta2_RollingUpdateStatefulSetStrategy(a.(*apps.RollingUpdateStatefulSetStrategy), b.(*appsv1beta2.RollingUpdateStatefulSetStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.Scale)(nil), (*autoscaling.Scale)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_Scale_To_autoscaling_Scale(a.(*appsv1beta2.Scale), b.(*autoscaling.Scale), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.Scale)(nil), (*appsv1beta2.Scale)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_Scale_To_v1beta2_Scale(a.(*autoscaling.Scale), b.(*appsv1beta2.Scale), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.ScaleSpec)(nil), (*autoscaling.ScaleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ScaleSpec_To_autoscaling_ScaleSpec(a.(*appsv1beta2.ScaleSpec), b.(*autoscaling.ScaleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ScaleSpec)(nil), (*appsv1beta2.ScaleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ScaleSpec_To_v1beta2_ScaleSpec(a.(*autoscaling.ScaleSpec), b.(*appsv1beta2.ScaleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.StatefulSet)(nil), (*apps.StatefulSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_StatefulSet_To_apps_StatefulSet(a.(*appsv1beta2.StatefulSet), b.(*apps.StatefulSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSet)(nil), (*appsv1beta2.StatefulSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSet_To_v1beta2_StatefulSet(a.(*apps.StatefulSet), b.(*appsv1beta2.StatefulSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.StatefulSetCondition)(nil), (*apps.StatefulSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_StatefulSetCondition_To_apps_StatefulSetCondition(a.(*appsv1beta2.StatefulSetCondition), b.(*apps.StatefulSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetCondition)(nil), (*appsv1beta2.StatefulSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetCondition_To_v1beta2_StatefulSetCondition(a.(*apps.StatefulSetCondition), b.(*appsv1beta2.StatefulSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.StatefulSetList)(nil), (*apps.StatefulSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_StatefulSetList_To_apps_StatefulSetList(a.(*appsv1beta2.StatefulSetList), b.(*apps.StatefulSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetList)(nil), (*appsv1beta2.StatefulSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetList_To_v1beta2_StatefulSetList(a.(*apps.StatefulSetList), b.(*appsv1beta2.StatefulSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.StatefulSetOrdinals)(nil), (*apps.StatefulSetOrdinals)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(a.(*appsv1beta2.StatefulSetOrdinals), b.(*apps.StatefulSetOrdinals), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetOrdinals)(nil), (*appsv1beta2.StatefulSetOrdinals)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetOrdinals_To_v1beta2_StatefulSetOrdinals(a.(*apps.StatefulSetOrdinals), b.(*appsv1beta2.StatefulSetOrdinals), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), (*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(a.(*appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy), b.(*apps.StatefulSetPersistentVolumeClaimRetentionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), (*appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy(a.(*apps.StatefulSetPersistentVolumeClaimRetentionPolicy), b.(*appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.StatefulSetStatus)(nil), (*apps.StatefulSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_StatefulSetStatus_To_apps_StatefulSetStatus(a.(*appsv1beta2.StatefulSetStatus), b.(*apps.StatefulSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetStatus)(nil), (*appsv1beta2.StatefulSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetStatus_To_v1beta2_StatefulSetStatus(a.(*apps.StatefulSetStatus), b.(*appsv1beta2.StatefulSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*appsv1beta2.StatefulSetUpdateStrategy)(nil), (*apps.StatefulSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(a.(*appsv1beta2.StatefulSetUpdateStrategy), b.(*apps.StatefulSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.StatefulSetUpdateStrategy)(nil), (*appsv1beta2.StatefulSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetUpdateStrategy_To_v1beta2_StatefulSetUpdateStrategy(a.(*apps.StatefulSetUpdateStrategy), b.(*appsv1beta2.StatefulSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.DaemonSetSpec)(nil), (*appsv1beta2.DaemonSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetSpec_To_v1beta2_DaemonSetSpec(a.(*apps.DaemonSetSpec), b.(*appsv1beta2.DaemonSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.DaemonSet)(nil), (*appsv1beta2.DaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSet_To_v1beta2_DaemonSet(a.(*apps.DaemonSet), b.(*appsv1beta2.DaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.DeploymentSpec)(nil), (*appsv1beta2.DeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentSpec_To_v1beta2_DeploymentSpec(a.(*apps.DeploymentSpec), b.(*appsv1beta2.DeploymentSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.Deployment)(nil), (*appsv1beta2.Deployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_Deployment_To_v1beta2_Deployment(a.(*apps.Deployment), b.(*appsv1beta2.Deployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.StatefulSetSpec)(nil), (*appsv1beta2.StatefulSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_StatefulSetSpec_To_v1beta2_StatefulSetSpec(a.(*apps.StatefulSetSpec), b.(*appsv1beta2.StatefulSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ScaleStatus)(nil), (*appsv1beta2.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ScaleStatus_To_v1beta2_ScaleStatus(a.(*autoscaling.ScaleStatus), b.(*appsv1beta2.ScaleStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1beta2.DaemonSet)(nil), (*apps.DaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_DaemonSet_To_apps_DaemonSet(a.(*appsv1beta2.DaemonSet), b.(*apps.DaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1beta2.Deployment)(nil), (*apps.Deployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_Deployment_To_apps_Deployment(a.(*appsv1beta2.Deployment), b.(*apps.Deployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1beta2.ScaleStatus)(nil), (*autoscaling.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_ScaleStatus_To_autoscaling_ScaleStatus(a.(*appsv1beta2.ScaleStatus), b.(*autoscaling.ScaleStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*appsv1beta2.StatefulSetSpec)(nil), (*apps.StatefulSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta2_StatefulSetSpec_To_apps_StatefulSetSpec(a.(*appsv1beta2.StatefulSetSpec), b.(*apps.StatefulSetSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta2_ControllerRevision_To_apps_ControllerRevision(in *appsv1beta2.ControllerRevision, out *apps.ControllerRevision, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Data = in.Data
        out.Revision = in.Revision
        return nil
}

// Convert_v1beta2_ControllerRevision_To_apps_ControllerRevision is an autogenerated conversion function.
func Convert_v1beta2_ControllerRevision_To_apps_ControllerRevision(in *appsv1beta2.ControllerRevision, out *apps.ControllerRevision, s conversion.Scope) error {
        return autoConvert_v1beta2_ControllerRevision_To_apps_ControllerRevision(in, out, s)
}

func autoConvert_apps_ControllerRevision_To_v1beta2_ControllerRevision(in *apps.ControllerRevision, out *appsv1beta2.ControllerRevision, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Data = in.Data
        out.Revision = in.Revision
        return nil
}

// Convert_apps_ControllerRevision_To_v1beta2_ControllerRevision is an autogenerated conversion function.
func Convert_apps_ControllerRevision_To_v1beta2_ControllerRevision(in *apps.ControllerRevision, out *appsv1beta2.ControllerRevision, s conversion.Scope) error {
        return autoConvert_apps_ControllerRevision_To_v1beta2_ControllerRevision(in, out, s)
}

func autoConvert_v1beta2_ControllerRevisionList_To_apps_ControllerRevisionList(in *appsv1beta2.ControllerRevisionList, out *apps.ControllerRevisionList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]apps.ControllerRevision)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1beta2_ControllerRevisionList_To_apps_ControllerRevisionList is an autogenerated conversion function.
func Convert_v1beta2_ControllerRevisionList_To_apps_ControllerRevisionList(in *appsv1beta2.ControllerRevisionList, out *apps.ControllerRevisionList, s conversion.Scope) error {
        return autoConvert_v1beta2_ControllerRevisionList_To_apps_ControllerRevisionList(in, out, s)
}

func autoConvert_apps_ControllerRevisionList_To_v1beta2_ControllerRevisionList(in *apps.ControllerRevisionList, out *appsv1beta2.ControllerRevisionList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]appsv1beta2.ControllerRevision)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_apps_ControllerRevisionList_To_v1beta2_ControllerRevisionList is an autogenerated conversion function.
func Convert_apps_ControllerRevisionList_To_v1beta2_ControllerRevisionList(in *apps.ControllerRevisionList, out *appsv1beta2.ControllerRevisionList, s conversion.Scope) error {
        return autoConvert_apps_ControllerRevisionList_To_v1beta2_ControllerRevisionList(in, out, s)
}

func autoConvert_v1beta2_DaemonSet_To_apps_DaemonSet(in *appsv1beta2.DaemonSet, out *apps.DaemonSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta2_DaemonSetSpec_To_apps_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta2_DaemonSetStatus_To_apps_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_apps_DaemonSet_To_v1beta2_DaemonSet(in *apps.DaemonSet, out *appsv1beta2.DaemonSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_DaemonSetSpec_To_v1beta2_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_DaemonSetStatus_To_v1beta2_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta2_DaemonSetCondition_To_apps_DaemonSetCondition(in *appsv1beta2.DaemonSetCondition, out *apps.DaemonSetCondition, s conversion.Scope) error {
        out.Type = apps.DaemonSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta2_DaemonSetCondition_To_apps_DaemonSetCondition is an autogenerated conversion function.
func Convert_v1beta2_DaemonSetCondition_To_apps_DaemonSetCondition(in *appsv1beta2.DaemonSetCondition, out *apps.DaemonSetCondition, s conversion.Scope) error {
        return autoConvert_v1beta2_DaemonSetCondition_To_apps_DaemonSetCondition(in, out, s)
}

func autoConvert_apps_DaemonSetCondition_To_v1beta2_DaemonSetCondition(in *apps.DaemonSetCondition, out *appsv1beta2.DaemonSetCondition, s conversion.Scope) error {
        out.Type = appsv1beta2.DaemonSetConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_DaemonSetCondition_To_v1beta2_DaemonSetCondition is an autogenerated conversion function.
func Convert_apps_DaemonSetCondition_To_v1beta2_DaemonSetCondition(in *apps.DaemonSetCondition, out *appsv1beta2.DaemonSetCondition, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetCondition_To_v1beta2_DaemonSetCondition(in, out, s)
}

func autoConvert_v1beta2_DaemonSetList_To_apps_DaemonSetList(in *appsv1beta2.DaemonSetList, out *apps.DaemonSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.DaemonSet, len(*in))
                for i := range *in {
                        if err := Convert_v1beta2_DaemonSet_To_apps_DaemonSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta2_DaemonSetList_To_apps_DaemonSetList is an autogenerated conversion function.
func Convert_v1beta2_DaemonSetList_To_apps_DaemonSetList(in *appsv1beta2.DaemonSetList, out *apps.DaemonSetList, s conversion.Scope) error {
        return autoConvert_v1beta2_DaemonSetList_To_apps_DaemonSetList(in, out, s)
}

func autoConvert_apps_DaemonSetList_To_v1beta2_DaemonSetList(in *apps.DaemonSetList, out *appsv1beta2.DaemonSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1beta2.DaemonSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_DaemonSet_To_v1beta2_DaemonSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_DaemonSetList_To_v1beta2_DaemonSetList is an autogenerated conversion function.
func Convert_apps_DaemonSetList_To_v1beta2_DaemonSetList(in *apps.DaemonSetList, out *appsv1beta2.DaemonSetList, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetList_To_v1beta2_DaemonSetList(in, out, s)
}

func autoConvert_v1beta2_DaemonSetSpec_To_apps_DaemonSetSpec(in *appsv1beta2.DaemonSetSpec, out *apps.DaemonSetSpec, s conversion.Scope) error {
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_v1beta2_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        return nil
}

// Convert_v1beta2_DaemonSetSpec_To_apps_DaemonSetSpec is an autogenerated conversion function.
func Convert_v1beta2_DaemonSetSpec_To_apps_DaemonSetSpec(in *appsv1beta2.DaemonSetSpec, out *apps.DaemonSetSpec, s conversion.Scope) error {
        return autoConvert_v1beta2_DaemonSetSpec_To_apps_DaemonSetSpec(in, out, s)
}

func autoConvert_apps_DaemonSetSpec_To_v1beta2_DaemonSetSpec(in *apps.DaemonSetSpec, out *appsv1beta2.DaemonSetSpec, s conversion.Scope) error {
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_apps_DaemonSetUpdateStrategy_To_v1beta2_DaemonSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        // WARNING: in.TemplateGeneration requires manual conversion: does not exist in peer-type
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        return nil
}

func autoConvert_v1beta2_DaemonSetStatus_To_apps_DaemonSetStatus(in *appsv1beta2.DaemonSetStatus, out *apps.DaemonSetStatus, s conversion.Scope) error {
        out.CurrentNumberScheduled = in.CurrentNumberScheduled
        out.NumberMisscheduled = in.NumberMisscheduled
        out.DesiredNumberScheduled = in.DesiredNumberScheduled
        out.NumberReady = in.NumberReady
        out.ObservedGeneration = in.ObservedGeneration
        out.UpdatedNumberScheduled = in.UpdatedNumberScheduled
        out.NumberAvailable = in.NumberAvailable
        out.NumberUnavailable = in.NumberUnavailable
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]apps.DaemonSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1beta2_DaemonSetStatus_To_apps_DaemonSetStatus is an autogenerated conversion function.
func Convert_v1beta2_DaemonSetStatus_To_apps_DaemonSetStatus(in *appsv1beta2.DaemonSetStatus, out *apps.DaemonSetStatus, s conversion.Scope) error {
        return autoConvert_v1beta2_DaemonSetStatus_To_apps_DaemonSetStatus(in, out, s)
}

func autoConvert_apps_DaemonSetStatus_To_v1beta2_DaemonSetStatus(in *apps.DaemonSetStatus, out *appsv1beta2.DaemonSetStatus, s conversion.Scope) error {
        out.CurrentNumberScheduled = in.CurrentNumberScheduled
        out.NumberMisscheduled = in.NumberMisscheduled
        out.DesiredNumberScheduled = in.DesiredNumberScheduled
        out.NumberReady = in.NumberReady
        out.ObservedGeneration = in.ObservedGeneration
        out.UpdatedNumberScheduled = in.UpdatedNumberScheduled
        out.NumberAvailable = in.NumberAvailable
        out.NumberUnavailable = in.NumberUnavailable
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]appsv1beta2.DaemonSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_apps_DaemonSetStatus_To_v1beta2_DaemonSetStatus is an autogenerated conversion function.
func Convert_apps_DaemonSetStatus_To_v1beta2_DaemonSetStatus(in *apps.DaemonSetStatus, out *appsv1beta2.DaemonSetStatus, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetStatus_To_v1beta2_DaemonSetStatus(in, out, s)
}

func autoConvert_v1beta2_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in *appsv1beta2.DaemonSetUpdateStrategy, out *apps.DaemonSetUpdateStrategy, s conversion.Scope) error {
        out.Type = apps.DaemonSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateDaemonSet)
                if err := Convert_v1beta2_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1beta2_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy is an autogenerated conversion function.
func Convert_v1beta2_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in *appsv1beta2.DaemonSetUpdateStrategy, out *apps.DaemonSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_v1beta2_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in, out, s)
}

func autoConvert_apps_DaemonSetUpdateStrategy_To_v1beta2_DaemonSetUpdateStrategy(in *apps.DaemonSetUpdateStrategy, out *appsv1beta2.DaemonSetUpdateStrategy, s conversion.Scope) error {
        out.Type = appsv1beta2.DaemonSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(appsv1beta2.RollingUpdateDaemonSet)
                if err := Convert_apps_RollingUpdateDaemonSet_To_v1beta2_RollingUpdateDaemonSet(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_DaemonSetUpdateStrategy_To_v1beta2_DaemonSetUpdateStrategy is an autogenerated conversion function.
func Convert_apps_DaemonSetUpdateStrategy_To_v1beta2_DaemonSetUpdateStrategy(in *apps.DaemonSetUpdateStrategy, out *appsv1beta2.DaemonSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetUpdateStrategy_To_v1beta2_DaemonSetUpdateStrategy(in, out, s)
}

func autoConvert_v1beta2_Deployment_To_apps_Deployment(in *appsv1beta2.Deployment, out *apps.Deployment, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta2_DeploymentSpec_To_apps_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta2_DeploymentStatus_To_apps_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_apps_Deployment_To_v1beta2_Deployment(in *apps.Deployment, out *appsv1beta2.Deployment, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_DeploymentSpec_To_v1beta2_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_DeploymentStatus_To_v1beta2_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta2_DeploymentCondition_To_apps_DeploymentCondition(in *appsv1beta2.DeploymentCondition, out *apps.DeploymentCondition, s conversion.Scope) error {
        out.Type = apps.DeploymentConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta2_DeploymentCondition_To_apps_DeploymentCondition is an autogenerated conversion function.
func Convert_v1beta2_DeploymentCondition_To_apps_DeploymentCondition(in *appsv1beta2.DeploymentCondition, out *apps.DeploymentCondition, s conversion.Scope) error {
        return autoConvert_v1beta2_DeploymentCondition_To_apps_DeploymentCondition(in, out, s)
}

func autoConvert_apps_DeploymentCondition_To_v1beta2_DeploymentCondition(in *apps.DeploymentCondition, out *appsv1beta2.DeploymentCondition, s conversion.Scope) error {
        out.Type = appsv1beta2.DeploymentConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_DeploymentCondition_To_v1beta2_DeploymentCondition is an autogenerated conversion function.
func Convert_apps_DeploymentCondition_To_v1beta2_DeploymentCondition(in *apps.DeploymentCondition, out *appsv1beta2.DeploymentCondition, s conversion.Scope) error {
        return autoConvert_apps_DeploymentCondition_To_v1beta2_DeploymentCondition(in, out, s)
}

func autoConvert_v1beta2_DeploymentList_To_apps_DeploymentList(in *appsv1beta2.DeploymentList, out *apps.DeploymentList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.Deployment, len(*in))
                for i := range *in {
                        if err := Convert_v1beta2_Deployment_To_apps_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta2_DeploymentList_To_apps_DeploymentList is an autogenerated conversion function.
func Convert_v1beta2_DeploymentList_To_apps_DeploymentList(in *appsv1beta2.DeploymentList, out *apps.DeploymentList, s conversion.Scope) error {
        return autoConvert_v1beta2_DeploymentList_To_apps_DeploymentList(in, out, s)
}

func autoConvert_apps_DeploymentList_To_v1beta2_DeploymentList(in *apps.DeploymentList, out *appsv1beta2.DeploymentList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1beta2.Deployment, len(*in))
                for i := range *in {
                        if err := Convert_apps_Deployment_To_v1beta2_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_DeploymentList_To_v1beta2_DeploymentList is an autogenerated conversion function.
func Convert_apps_DeploymentList_To_v1beta2_DeploymentList(in *apps.DeploymentList, out *appsv1beta2.DeploymentList, s conversion.Scope) error {
        return autoConvert_apps_DeploymentList_To_v1beta2_DeploymentList(in, out, s)
}

func autoConvert_v1beta2_DeploymentSpec_To_apps_DeploymentSpec(in *appsv1beta2.DeploymentSpec, out *apps.DeploymentSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_v1beta2_DeploymentStrategy_To_apps_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.Paused = in.Paused
        out.ProgressDeadlineSeconds = (*int32)(unsafe.Pointer(in.ProgressDeadlineSeconds))
        return nil
}

// Convert_v1beta2_DeploymentSpec_To_apps_DeploymentSpec is an autogenerated conversion function.
func Convert_v1beta2_DeploymentSpec_To_apps_DeploymentSpec(in *appsv1beta2.DeploymentSpec, out *apps.DeploymentSpec, s conversion.Scope) error {
        return autoConvert_v1beta2_DeploymentSpec_To_apps_DeploymentSpec(in, out, s)
}

func autoConvert_apps_DeploymentSpec_To_v1beta2_DeploymentSpec(in *apps.DeploymentSpec, out *appsv1beta2.DeploymentSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_apps_DeploymentStrategy_To_v1beta2_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.Paused = in.Paused
        // WARNING: in.RollbackTo requires manual conversion: does not exist in peer-type
        out.ProgressDeadlineSeconds = (*int32)(unsafe.Pointer(in.ProgressDeadlineSeconds))
        return nil
}

func autoConvert_v1beta2_DeploymentStatus_To_apps_DeploymentStatus(in *appsv1beta2.DeploymentStatus, out *apps.DeploymentStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Replicas = in.Replicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.UnavailableReplicas = in.UnavailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.Conditions = *(*[]apps.DeploymentCondition)(unsafe.Pointer(&in.Conditions))
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        return nil
}

// Convert_v1beta2_DeploymentStatus_To_apps_DeploymentStatus is an autogenerated conversion function.
func Convert_v1beta2_DeploymentStatus_To_apps_DeploymentStatus(in *appsv1beta2.DeploymentStatus, out *apps.DeploymentStatus, s conversion.Scope) error {
        return autoConvert_v1beta2_DeploymentStatus_To_apps_DeploymentStatus(in, out, s)
}

func autoConvert_apps_DeploymentStatus_To_v1beta2_DeploymentStatus(in *apps.DeploymentStatus, out *appsv1beta2.DeploymentStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Replicas = in.Replicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.UnavailableReplicas = in.UnavailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.Conditions = *(*[]appsv1beta2.DeploymentCondition)(unsafe.Pointer(&in.Conditions))
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        return nil
}

// Convert_apps_DeploymentStatus_To_v1beta2_DeploymentStatus is an autogenerated conversion function.
func Convert_apps_DeploymentStatus_To_v1beta2_DeploymentStatus(in *apps.DeploymentStatus, out *appsv1beta2.DeploymentStatus, s conversion.Scope) error {
        return autoConvert_apps_DeploymentStatus_To_v1beta2_DeploymentStatus(in, out, s)
}

func autoConvert_v1beta2_DeploymentStrategy_To_apps_DeploymentStrategy(in *appsv1beta2.DeploymentStrategy, out *apps.DeploymentStrategy, s conversion.Scope) error {
        out.Type = apps.DeploymentStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateDeployment)
                if err := Convert_v1beta2_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1beta2_DeploymentStrategy_To_apps_DeploymentStrategy is an autogenerated conversion function.
func Convert_v1beta2_DeploymentStrategy_To_apps_DeploymentStrategy(in *appsv1beta2.DeploymentStrategy, out *apps.DeploymentStrategy, s conversion.Scope) error {
        return autoConvert_v1beta2_DeploymentStrategy_To_apps_DeploymentStrategy(in, out, s)
}

func autoConvert_apps_DeploymentStrategy_To_v1beta2_DeploymentStrategy(in *apps.DeploymentStrategy, out *appsv1beta2.DeploymentStrategy, s conversion.Scope) error {
        out.Type = appsv1beta2.DeploymentStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(appsv1beta2.RollingUpdateDeployment)
                if err := Convert_apps_RollingUpdateDeployment_To_v1beta2_RollingUpdateDeployment(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_DeploymentStrategy_To_v1beta2_DeploymentStrategy is an autogenerated conversion function.
func Convert_apps_DeploymentStrategy_To_v1beta2_DeploymentStrategy(in *apps.DeploymentStrategy, out *appsv1beta2.DeploymentStrategy, s conversion.Scope) error {
        return autoConvert_apps_DeploymentStrategy_To_v1beta2_DeploymentStrategy(in, out, s)
}

func autoConvert_v1beta2_ReplicaSet_To_apps_ReplicaSet(in *appsv1beta2.ReplicaSet, out *apps.ReplicaSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta2_ReplicaSetSpec_To_apps_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta2_ReplicaSetStatus_To_apps_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta2_ReplicaSet_To_apps_ReplicaSet is an autogenerated conversion function.
func Convert_v1beta2_ReplicaSet_To_apps_ReplicaSet(in *appsv1beta2.ReplicaSet, out *apps.ReplicaSet, s conversion.Scope) error {
        return autoConvert_v1beta2_ReplicaSet_To_apps_ReplicaSet(in, out, s)
}

func autoConvert_apps_ReplicaSet_To_v1beta2_ReplicaSet(in *apps.ReplicaSet, out *appsv1beta2.ReplicaSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_ReplicaSetSpec_To_v1beta2_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_ReplicaSetStatus_To_v1beta2_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_ReplicaSet_To_v1beta2_ReplicaSet is an autogenerated conversion function.
func Convert_apps_ReplicaSet_To_v1beta2_ReplicaSet(in *apps.ReplicaSet, out *appsv1beta2.ReplicaSet, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSet_To_v1beta2_ReplicaSet(in, out, s)
}

func autoConvert_v1beta2_ReplicaSetCondition_To_apps_ReplicaSetCondition(in *appsv1beta2.ReplicaSetCondition, out *apps.ReplicaSetCondition, s conversion.Scope) error {
        out.Type = apps.ReplicaSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta2_ReplicaSetCondition_To_apps_ReplicaSetCondition is an autogenerated conversion function.
func Convert_v1beta2_ReplicaSetCondition_To_apps_ReplicaSetCondition(in *appsv1beta2.ReplicaSetCondition, out *apps.ReplicaSetCondition, s conversion.Scope) error {
        return autoConvert_v1beta2_ReplicaSetCondition_To_apps_ReplicaSetCondition(in, out, s)
}

func autoConvert_apps_ReplicaSetCondition_To_v1beta2_ReplicaSetCondition(in *apps.ReplicaSetCondition, out *appsv1beta2.ReplicaSetCondition, s conversion.Scope) error {
        out.Type = appsv1beta2.ReplicaSetConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_ReplicaSetCondition_To_v1beta2_ReplicaSetCondition is an autogenerated conversion function.
func Convert_apps_ReplicaSetCondition_To_v1beta2_ReplicaSetCondition(in *apps.ReplicaSetCondition, out *appsv1beta2.ReplicaSetCondition, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetCondition_To_v1beta2_ReplicaSetCondition(in, out, s)
}

func autoConvert_v1beta2_ReplicaSetList_To_apps_ReplicaSetList(in *appsv1beta2.ReplicaSetList, out *apps.ReplicaSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.ReplicaSet, len(*in))
                for i := range *in {
                        if err := Convert_v1beta2_ReplicaSet_To_apps_ReplicaSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta2_ReplicaSetList_To_apps_ReplicaSetList is an autogenerated conversion function.
func Convert_v1beta2_ReplicaSetList_To_apps_ReplicaSetList(in *appsv1beta2.ReplicaSetList, out *apps.ReplicaSetList, s conversion.Scope) error {
        return autoConvert_v1beta2_ReplicaSetList_To_apps_ReplicaSetList(in, out, s)
}

func autoConvert_apps_ReplicaSetList_To_v1beta2_ReplicaSetList(in *apps.ReplicaSetList, out *appsv1beta2.ReplicaSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1beta2.ReplicaSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_ReplicaSet_To_v1beta2_ReplicaSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_ReplicaSetList_To_v1beta2_ReplicaSetList is an autogenerated conversion function.
func Convert_apps_ReplicaSetList_To_v1beta2_ReplicaSetList(in *apps.ReplicaSetList, out *appsv1beta2.ReplicaSetList, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetList_To_v1beta2_ReplicaSetList(in, out, s)
}

func autoConvert_v1beta2_ReplicaSetSpec_To_apps_ReplicaSetSpec(in *appsv1beta2.ReplicaSetSpec, out *apps.ReplicaSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta2_ReplicaSetSpec_To_apps_ReplicaSetSpec is an autogenerated conversion function.
func Convert_v1beta2_ReplicaSetSpec_To_apps_ReplicaSetSpec(in *appsv1beta2.ReplicaSetSpec, out *apps.ReplicaSetSpec, s conversion.Scope) error {
        return autoConvert_v1beta2_ReplicaSetSpec_To_apps_ReplicaSetSpec(in, out, s)
}

func autoConvert_apps_ReplicaSetSpec_To_v1beta2_ReplicaSetSpec(in *apps.ReplicaSetSpec, out *appsv1beta2.ReplicaSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_ReplicaSetSpec_To_v1beta2_ReplicaSetSpec is an autogenerated conversion function.
func Convert_apps_ReplicaSetSpec_To_v1beta2_ReplicaSetSpec(in *apps.ReplicaSetSpec, out *appsv1beta2.ReplicaSetSpec, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetSpec_To_v1beta2_ReplicaSetSpec(in, out, s)
}

func autoConvert_v1beta2_ReplicaSetStatus_To_apps_ReplicaSetStatus(in *appsv1beta2.ReplicaSetStatus, out *apps.ReplicaSetStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.ObservedGeneration = in.ObservedGeneration
        out.Conditions = *(*[]apps.ReplicaSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1beta2_ReplicaSetStatus_To_apps_ReplicaSetStatus is an autogenerated conversion function.
func Convert_v1beta2_ReplicaSetStatus_To_apps_ReplicaSetStatus(in *appsv1beta2.ReplicaSetStatus, out *apps.ReplicaSetStatus, s conversion.Scope) error {
        return autoConvert_v1beta2_ReplicaSetStatus_To_apps_ReplicaSetStatus(in, out, s)
}

func autoConvert_apps_ReplicaSetStatus_To_v1beta2_ReplicaSetStatus(in *apps.ReplicaSetStatus, out *appsv1beta2.ReplicaSetStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.ObservedGeneration = in.ObservedGeneration
        out.Conditions = *(*[]appsv1beta2.ReplicaSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_apps_ReplicaSetStatus_To_v1beta2_ReplicaSetStatus is an autogenerated conversion function.
func Convert_apps_ReplicaSetStatus_To_v1beta2_ReplicaSetStatus(in *apps.ReplicaSetStatus, out *appsv1beta2.ReplicaSetStatus, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetStatus_To_v1beta2_ReplicaSetStatus(in, out, s)
}

func autoConvert_v1beta2_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in *appsv1beta2.RollingUpdateDaemonSet, out *apps.RollingUpdateDaemonSet, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta2_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet is an autogenerated conversion function.
func Convert_v1beta2_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in *appsv1beta2.RollingUpdateDaemonSet, out *apps.RollingUpdateDaemonSet, s conversion.Scope) error {
        return autoConvert_v1beta2_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in, out, s)
}

func autoConvert_apps_RollingUpdateDaemonSet_To_v1beta2_RollingUpdateDaemonSet(in *apps.RollingUpdateDaemonSet, out *appsv1beta2.RollingUpdateDaemonSet, s conversion.Scope) error {
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_RollingUpdateDaemonSet_To_v1beta2_RollingUpdateDaemonSet is an autogenerated conversion function.
func Convert_apps_RollingUpdateDaemonSet_To_v1beta2_RollingUpdateDaemonSet(in *apps.RollingUpdateDaemonSet, out *appsv1beta2.RollingUpdateDaemonSet, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateDaemonSet_To_v1beta2_RollingUpdateDaemonSet(in, out, s)
}

func autoConvert_v1beta2_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in *appsv1beta2.RollingUpdateDeployment, out *apps.RollingUpdateDeployment, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta2_RollingUpdateDeployment_To_apps_RollingUpdateDeployment is an autogenerated conversion function.
func Convert_v1beta2_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in *appsv1beta2.RollingUpdateDeployment, out *apps.RollingUpdateDeployment, s conversion.Scope) error {
        return autoConvert_v1beta2_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in, out, s)
}

func autoConvert_apps_RollingUpdateDeployment_To_v1beta2_RollingUpdateDeployment(in *apps.RollingUpdateDeployment, out *appsv1beta2.RollingUpdateDeployment, s conversion.Scope) error {
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_RollingUpdateDeployment_To_v1beta2_RollingUpdateDeployment is an autogenerated conversion function.
func Convert_apps_RollingUpdateDeployment_To_v1beta2_RollingUpdateDeployment(in *apps.RollingUpdateDeployment, out *appsv1beta2.RollingUpdateDeployment, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateDeployment_To_v1beta2_RollingUpdateDeployment(in, out, s)
}

func autoConvert_v1beta2_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *appsv1beta2.RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Partition, &out.Partition, s); err != nil {
                return err
        }
        out.MaxUnavailable = (*intstr.IntOrString)(unsafe.Pointer(in.MaxUnavailable))
        return nil
}

// Convert_v1beta2_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
func Convert_v1beta2_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *appsv1beta2.RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        return autoConvert_v1beta2_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in, out, s)
}

func autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1beta2_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *appsv1beta2.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Partition, &out.Partition, s); err != nil {
                return err
        }
        out.MaxUnavailable = (*intstr.IntOrString)(unsafe.Pointer(in.MaxUnavailable))
        return nil
}

// Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta2_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
func Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta2_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *appsv1beta2.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1beta2_RollingUpdateStatefulSetStrategy(in, out, s)
}

func autoConvert_v1beta2_Scale_To_autoscaling_Scale(in *appsv1beta2.Scale, out *autoscaling.Scale, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta2_ScaleSpec_To_autoscaling_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta2_ScaleStatus_To_autoscaling_ScaleStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta2_Scale_To_autoscaling_Scale is an autogenerated conversion function.
func Convert_v1beta2_Scale_To_autoscaling_Scale(in *appsv1beta2.Scale, out *autoscaling.Scale, s conversion.Scope) error {
        return autoConvert_v1beta2_Scale_To_autoscaling_Scale(in, out, s)
}

func autoConvert_autoscaling_Scale_To_v1beta2_Scale(in *autoscaling.Scale, out *appsv1beta2.Scale, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_autoscaling_ScaleSpec_To_v1beta2_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_ScaleStatus_To_v1beta2_ScaleStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_Scale_To_v1beta2_Scale is an autogenerated conversion function.
func Convert_autoscaling_Scale_To_v1beta2_Scale(in *autoscaling.Scale, out *appsv1beta2.Scale, s conversion.Scope) error {
        return autoConvert_autoscaling_Scale_To_v1beta2_Scale(in, out, s)
}

func autoConvert_v1beta2_ScaleSpec_To_autoscaling_ScaleSpec(in *appsv1beta2.ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
        out.Replicas = in.Replicas
        return nil
}

// Convert_v1beta2_ScaleSpec_To_autoscaling_ScaleSpec is an autogenerated conversion function.
func Convert_v1beta2_ScaleSpec_To_autoscaling_ScaleSpec(in *appsv1beta2.ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
        return autoConvert_v1beta2_ScaleSpec_To_autoscaling_ScaleSpec(in, out, s)
}

func autoConvert_autoscaling_ScaleSpec_To_v1beta2_ScaleSpec(in *autoscaling.ScaleSpec, out *appsv1beta2.ScaleSpec, s conversion.Scope) error {
        out.Replicas = in.Replicas
        return nil
}

// Convert_autoscaling_ScaleSpec_To_v1beta2_ScaleSpec is an autogenerated conversion function.
func Convert_autoscaling_ScaleSpec_To_v1beta2_ScaleSpec(in *autoscaling.ScaleSpec, out *appsv1beta2.ScaleSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_ScaleSpec_To_v1beta2_ScaleSpec(in, out, s)
}

func autoConvert_v1beta2_ScaleStatus_To_autoscaling_ScaleStatus(in *appsv1beta2.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        // WARNING: in.Selector requires manual conversion: inconvertible types (map[string]string vs string)
        // WARNING: in.TargetSelector requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ScaleStatus_To_v1beta2_ScaleStatus(in *autoscaling.ScaleStatus, out *appsv1beta2.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        // WARNING: in.Selector requires manual conversion: inconvertible types (string vs map[string]string)
        return nil
}

func autoConvert_v1beta2_StatefulSet_To_apps_StatefulSet(in *appsv1beta2.StatefulSet, out *apps.StatefulSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta2_StatefulSetSpec_To_apps_StatefulSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta2_StatefulSetStatus_To_apps_StatefulSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta2_StatefulSet_To_apps_StatefulSet is an autogenerated conversion function.
func Convert_v1beta2_StatefulSet_To_apps_StatefulSet(in *appsv1beta2.StatefulSet, out *apps.StatefulSet, s conversion.Scope) error {
        return autoConvert_v1beta2_StatefulSet_To_apps_StatefulSet(in, out, s)
}

func autoConvert_apps_StatefulSet_To_v1beta2_StatefulSet(in *apps.StatefulSet, out *appsv1beta2.StatefulSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_StatefulSetSpec_To_v1beta2_StatefulSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_StatefulSetStatus_To_v1beta2_StatefulSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_StatefulSet_To_v1beta2_StatefulSet is an autogenerated conversion function.
func Convert_apps_StatefulSet_To_v1beta2_StatefulSet(in *apps.StatefulSet, out *appsv1beta2.StatefulSet, s conversion.Scope) error {
        return autoConvert_apps_StatefulSet_To_v1beta2_StatefulSet(in, out, s)
}

func autoConvert_v1beta2_StatefulSetCondition_To_apps_StatefulSetCondition(in *appsv1beta2.StatefulSetCondition, out *apps.StatefulSetCondition, s conversion.Scope) error {
        out.Type = apps.StatefulSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta2_StatefulSetCondition_To_apps_StatefulSetCondition is an autogenerated conversion function.
func Convert_v1beta2_StatefulSetCondition_To_apps_StatefulSetCondition(in *appsv1beta2.StatefulSetCondition, out *apps.StatefulSetCondition, s conversion.Scope) error {
        return autoConvert_v1beta2_StatefulSetCondition_To_apps_StatefulSetCondition(in, out, s)
}

func autoConvert_apps_StatefulSetCondition_To_v1beta2_StatefulSetCondition(in *apps.StatefulSetCondition, out *appsv1beta2.StatefulSetCondition, s conversion.Scope) error {
        out.Type = appsv1beta2.StatefulSetConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_StatefulSetCondition_To_v1beta2_StatefulSetCondition is an autogenerated conversion function.
func Convert_apps_StatefulSetCondition_To_v1beta2_StatefulSetCondition(in *apps.StatefulSetCondition, out *appsv1beta2.StatefulSetCondition, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetCondition_To_v1beta2_StatefulSetCondition(in, out, s)
}

func autoConvert_v1beta2_StatefulSetList_To_apps_StatefulSetList(in *appsv1beta2.StatefulSetList, out *apps.StatefulSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.StatefulSet, len(*in))
                for i := range *in {
                        if err := Convert_v1beta2_StatefulSet_To_apps_StatefulSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta2_StatefulSetList_To_apps_StatefulSetList is an autogenerated conversion function.
func Convert_v1beta2_StatefulSetList_To_apps_StatefulSetList(in *appsv1beta2.StatefulSetList, out *apps.StatefulSetList, s conversion.Scope) error {
        return autoConvert_v1beta2_StatefulSetList_To_apps_StatefulSetList(in, out, s)
}

func autoConvert_apps_StatefulSetList_To_v1beta2_StatefulSetList(in *apps.StatefulSetList, out *appsv1beta2.StatefulSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]appsv1beta2.StatefulSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_StatefulSet_To_v1beta2_StatefulSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_StatefulSetList_To_v1beta2_StatefulSetList is an autogenerated conversion function.
func Convert_apps_StatefulSetList_To_v1beta2_StatefulSetList(in *apps.StatefulSetList, out *appsv1beta2.StatefulSetList, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetList_To_v1beta2_StatefulSetList(in, out, s)
}

func autoConvert_v1beta2_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in *appsv1beta2.StatefulSetOrdinals, out *apps.StatefulSetOrdinals, s conversion.Scope) error {
        out.Start = in.Start
        return nil
}

// Convert_v1beta2_StatefulSetOrdinals_To_apps_StatefulSetOrdinals is an autogenerated conversion function.
func Convert_v1beta2_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in *appsv1beta2.StatefulSetOrdinals, out *apps.StatefulSetOrdinals, s conversion.Scope) error {
        return autoConvert_v1beta2_StatefulSetOrdinals_To_apps_StatefulSetOrdinals(in, out, s)
}

func autoConvert_apps_StatefulSetOrdinals_To_v1beta2_StatefulSetOrdinals(in *apps.StatefulSetOrdinals, out *appsv1beta2.StatefulSetOrdinals, s conversion.Scope) error {
        out.Start = in.Start
        return nil
}

// Convert_apps_StatefulSetOrdinals_To_v1beta2_StatefulSetOrdinals is an autogenerated conversion function.
func Convert_apps_StatefulSetOrdinals_To_v1beta2_StatefulSetOrdinals(in *apps.StatefulSetOrdinals, out *appsv1beta2.StatefulSetOrdinals, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetOrdinals_To_v1beta2_StatefulSetOrdinals(in, out, s)
}

func autoConvert_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in *appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy, out *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        out.WhenDeleted = apps.PersistentVolumeClaimRetentionPolicyType(in.WhenDeleted)
        out.WhenScaled = apps.PersistentVolumeClaimRetentionPolicyType(in.WhenScaled)
        return nil
}

// Convert_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy is an autogenerated conversion function.
func Convert_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in *appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy, out *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        return autoConvert_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy_To_apps_StatefulSetPersistentVolumeClaimRetentionPolicy(in, out, s)
}

func autoConvert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy(in *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, out *appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        out.WhenDeleted = appsv1beta2.PersistentVolumeClaimRetentionPolicyType(in.WhenDeleted)
        out.WhenScaled = appsv1beta2.PersistentVolumeClaimRetentionPolicyType(in.WhenScaled)
        return nil
}

// Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy is an autogenerated conversion function.
func Convert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy(in *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, out *appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetPersistentVolumeClaimRetentionPolicy_To_v1beta2_StatefulSetPersistentVolumeClaimRetentionPolicy(in, out, s)
}

func autoConvert_v1beta2_StatefulSetSpec_To_apps_StatefulSetSpec(in *appsv1beta2.StatefulSetSpec, out *apps.StatefulSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        out.VolumeClaimTemplates = *(*[]core.PersistentVolumeClaim)(unsafe.Pointer(&in.VolumeClaimTemplates))
        out.ServiceName = in.ServiceName
        out.PodManagementPolicy = apps.PodManagementPolicyType(in.PodManagementPolicy)
        if err := Convert_v1beta2_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.MinReadySeconds = in.MinReadySeconds
        out.PersistentVolumeClaimRetentionPolicy = (*apps.StatefulSetPersistentVolumeClaimRetentionPolicy)(unsafe.Pointer(in.PersistentVolumeClaimRetentionPolicy))
        out.Ordinals = (*apps.StatefulSetOrdinals)(unsafe.Pointer(in.Ordinals))
        return nil
}

func autoConvert_apps_StatefulSetSpec_To_v1beta2_StatefulSetSpec(in *apps.StatefulSetSpec, out *appsv1beta2.StatefulSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        out.VolumeClaimTemplates = *(*[]v1.PersistentVolumeClaim)(unsafe.Pointer(&in.VolumeClaimTemplates))
        out.ServiceName = in.ServiceName
        out.PodManagementPolicy = appsv1beta2.PodManagementPolicyType(in.PodManagementPolicy)
        if err := Convert_apps_StatefulSetUpdateStrategy_To_v1beta2_StatefulSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.MinReadySeconds = in.MinReadySeconds
        out.PersistentVolumeClaimRetentionPolicy = (*appsv1beta2.StatefulSetPersistentVolumeClaimRetentionPolicy)(unsafe.Pointer(in.PersistentVolumeClaimRetentionPolicy))
        out.Ordinals = (*appsv1beta2.StatefulSetOrdinals)(unsafe.Pointer(in.Ordinals))
        return nil
}

func autoConvert_v1beta2_StatefulSetStatus_To_apps_StatefulSetStatus(in *appsv1beta2.StatefulSetStatus, out *apps.StatefulSetStatus, s conversion.Scope) error {
        if err := metav1.Convert_int64_To_Pointer_int64(&in.ObservedGeneration, &out.ObservedGeneration, s); err != nil {
                return err
        }
        out.Replicas = in.Replicas
        out.ReadyReplicas = in.ReadyReplicas
        out.CurrentReplicas = in.CurrentReplicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.CurrentRevision = in.CurrentRevision
        out.UpdateRevision = in.UpdateRevision
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]apps.StatefulSetCondition)(unsafe.Pointer(&in.Conditions))
        out.AvailableReplicas = in.AvailableReplicas
        return nil
}

// Convert_v1beta2_StatefulSetStatus_To_apps_StatefulSetStatus is an autogenerated conversion function.
func Convert_v1beta2_StatefulSetStatus_To_apps_StatefulSetStatus(in *appsv1beta2.StatefulSetStatus, out *apps.StatefulSetStatus, s conversion.Scope) error {
        return autoConvert_v1beta2_StatefulSetStatus_To_apps_StatefulSetStatus(in, out, s)
}

func autoConvert_apps_StatefulSetStatus_To_v1beta2_StatefulSetStatus(in *apps.StatefulSetStatus, out *appsv1beta2.StatefulSetStatus, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int64_To_int64(&in.ObservedGeneration, &out.ObservedGeneration, s); err != nil {
                return err
        }
        out.Replicas = in.Replicas
        out.ReadyReplicas = in.ReadyReplicas
        out.CurrentReplicas = in.CurrentReplicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.CurrentRevision = in.CurrentRevision
        out.UpdateRevision = in.UpdateRevision
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]appsv1beta2.StatefulSetCondition)(unsafe.Pointer(&in.Conditions))
        out.AvailableReplicas = in.AvailableReplicas
        return nil
}

// Convert_apps_StatefulSetStatus_To_v1beta2_StatefulSetStatus is an autogenerated conversion function.
func Convert_apps_StatefulSetStatus_To_v1beta2_StatefulSetStatus(in *apps.StatefulSetStatus, out *appsv1beta2.StatefulSetStatus, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetStatus_To_v1beta2_StatefulSetStatus(in, out, s)
}

func autoConvert_v1beta2_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in *appsv1beta2.StatefulSetUpdateStrategy, out *apps.StatefulSetUpdateStrategy, s conversion.Scope) error {
        out.Type = apps.StatefulSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateStatefulSetStrategy)
                if err := Convert_v1beta2_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1beta2_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy is an autogenerated conversion function.
func Convert_v1beta2_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in *appsv1beta2.StatefulSetUpdateStrategy, out *apps.StatefulSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_v1beta2_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in, out, s)
}

func autoConvert_apps_StatefulSetUpdateStrategy_To_v1beta2_StatefulSetUpdateStrategy(in *apps.StatefulSetUpdateStrategy, out *appsv1beta2.StatefulSetUpdateStrategy, s conversion.Scope) error {
        out.Type = appsv1beta2.StatefulSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(appsv1beta2.RollingUpdateStatefulSetStrategy)
                if err := Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta2_RollingUpdateStatefulSetStrategy(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_StatefulSetUpdateStrategy_To_v1beta2_StatefulSetUpdateStrategy is an autogenerated conversion function.
func Convert_apps_StatefulSetUpdateStrategy_To_v1beta2_StatefulSetUpdateStrategy(in *apps.StatefulSetUpdateStrategy, out *appsv1beta2.StatefulSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_apps_StatefulSetUpdateStrategy_To_v1beta2_StatefulSetUpdateStrategy(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta2

import (
        appsv1beta2 "k8s.io/api/apps/v1beta2"
        v1 "k8s.io/api/core/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&appsv1beta2.DaemonSet{}, func(obj interface{}) { SetObjectDefaults_DaemonSet(obj.(*appsv1beta2.DaemonSet)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta2.DaemonSetList{}, func(obj interface{}) { SetObjectDefaults_DaemonSetList(obj.(*appsv1beta2.DaemonSetList)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta2.Deployment{}, func(obj interface{}) { SetObjectDefaults_Deployment(obj.(*appsv1beta2.Deployment)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta2.DeploymentList{}, func(obj interface{}) { SetObjectDefaults_DeploymentList(obj.(*appsv1beta2.DeploymentList)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta2.ReplicaSet{}, func(obj interface{}) { SetObjectDefaults_ReplicaSet(obj.(*appsv1beta2.ReplicaSet)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta2.ReplicaSetList{}, func(obj interface{}) { SetObjectDefaults_ReplicaSetList(obj.(*appsv1beta2.ReplicaSetList)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta2.StatefulSet{}, func(obj interface{}) { SetObjectDefaults_StatefulSet(obj.(*appsv1beta2.StatefulSet)) })
        scheme.AddTypeDefaultingFunc(&appsv1beta2.StatefulSetList{}, func(obj interface{}) { SetObjectDefaults_StatefulSetList(obj.(*appsv1beta2.StatefulSetList)) })
        return nil
}

func SetObjectDefaults_DaemonSet(in *appsv1beta2.DaemonSet) {
        SetDefaults_DaemonSet(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_DaemonSetList(in *appsv1beta2.DaemonSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_DaemonSet(a)
        }
}

func SetObjectDefaults_Deployment(in *appsv1beta2.Deployment) {
        SetDefaults_Deployment(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_DeploymentList(in *appsv1beta2.DeploymentList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Deployment(a)
        }
}

func SetObjectDefaults_ReplicaSet(in *appsv1beta2.ReplicaSet) {
        SetDefaults_ReplicaSet(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_ReplicaSetList(in *appsv1beta2.ReplicaSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ReplicaSet(a)
        }
}

func SetObjectDefaults_StatefulSet(in *appsv1beta2.StatefulSet) {
        SetDefaults_StatefulSet(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
        for i := range in.Spec.VolumeClaimTemplates {
                a := &in.Spec.VolumeClaimTemplates[i]
                corev1.SetDefaults_PersistentVolumeClaim(a)
                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.Spec)
                corev1.SetDefaults_ResourceList(&a.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Spec.Resources.Requests)
                corev1.SetDefaults_ResourceList(&a.Status.Capacity)
                corev1.SetDefaults_ResourceList(&a.Status.AllocatedResources)
        }
}

func SetObjectDefaults_StatefulSetList(in *appsv1beta2.StatefulSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_StatefulSet(a)
        }
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 validation-gen. DO NOT EDIT.

package v1beta2

import (
        context "context"
        fmt "fmt"

        appsv1beta2 "k8s.io/api/apps/v1beta2"
        operation "k8s.io/apimachinery/pkg/api/operation"
        safe "k8s.io/apimachinery/pkg/api/safe"
        validate "k8s.io/apimachinery/pkg/api/validate"
        runtime "k8s.io/apimachinery/pkg/runtime"
        field "k8s.io/apimachinery/pkg/util/validation/field"
)

func init() { localSchemeBuilder.Register(RegisterValidations) }

// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
        scheme.AddValidationFunc((*appsv1beta2.Scale)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/scale":
                        return Validate_Scale(ctx, op, nil /* fldPath */, obj.(*appsv1beta2.Scale), safe.Cast[*appsv1beta2.Scale](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        return nil
}

func Validate_Scale(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *appsv1beta2.Scale) (errs field.ErrorList) {
        // field appsv1beta2.Scale.TypeMeta has no validation
        // field appsv1beta2.Scale.ObjectMeta has no validation

        // field appsv1beta2.Scale.Spec
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *appsv1beta2.ScaleSpec) (errs field.ErrorList) {
                        errs = append(errs, Validate_ScaleSpec(ctx, op, fldPath, obj, oldObj)...)
                        return
                }(fldPath.Child("spec"), &obj.Spec, safe.Field(oldObj, func(oldObj *appsv1beta2.Scale) *appsv1beta2.ScaleSpec { return &oldObj.Spec }))...)

        // field appsv1beta2.Scale.Status has no validation
        return errs
}

func Validate_ScaleSpec(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *appsv1beta2.ScaleSpec) (errs field.ErrorList) {
        // field appsv1beta2.ScaleSpec.Replicas
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *int32) (errs field.ErrorList) {
                        // optional value-type fields with zero-value defaults are purely documentation
                        if op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
                                return nil // no changes
                        }
                        errs = append(errs, validate.Minimum(ctx, op, fldPath, obj, oldObj, 0)...)
                        return
                }(fldPath.Child("replicas"), &obj.Replicas, safe.Field(oldObj, func(oldObj *appsv1beta2.ScaleSpec) *int32 { return &oldObj.Replicas }))...)

        return errs
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package validation

import (
        "encoding/json"
        "fmt"
        "strconv"

        apiequality "k8s.io/apimachinery/pkg/api/equality"
        apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        unversionedvalidation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/apimachinery/pkg/util/intstr"
        "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
        "k8s.io/kubernetes/pkg/apis/apps"
        api "k8s.io/kubernetes/pkg/apis/core"
        apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
)

// StatefulSetValidationOptions is a struct that can be passed to ValidateStatefulSetSpec to record the validate options
type StatefulSetValidationOptions struct {
        // Allow invalid DNS1123 ServiceName
        AllowInvalidServiceName bool
        // Skip validating pod template spec, which is used for StatefulSet update
        SkipValidatePodTemplateSpec bool
        // Skip validating volume claim templates, which is used for StatefulSet update
        SkipValidateVolumeClaimTemplates bool
}

// ValidateStatefulSetName can be used to check whether the given StatefulSet name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
func ValidateStatefulSetName(name string, prefix bool) []string {
        // TODO: Validate that there's room for the suffix inserted by the pods.
        // Currently this is just "-index". In the future we may allow a user
        // specified list of suffixes and we need  to validate the longest one.
        return apimachineryvalidation.NameIsDNSLabel(name, prefix)
}

// ValidatePodTemplateSpecForStatefulSet validates the given template and ensures that it is in accordance with the desired selector.
func ValidatePodTemplateSpecForStatefulSet(template *api.PodTemplateSpec, selector labels.Selector, fldPath *field.Path, opts apivalidation.PodValidationOptions,
        setOpts StatefulSetValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if template == nil {
                allErrs = append(allErrs, field.Required(fldPath, ""))
        } else {
                if !selector.Empty() {
                        // Verify that the StatefulSet selector matches the labels in template.
                        labels := labels.Set(template.Labels)
                        if !selector.Matches(labels) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("metadata", "labels"), template.Labels, "`selector` does not match template `labels`"))
                        }
                }
                if !setOpts.SkipValidatePodTemplateSpec {
                        allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpec(template, fldPath, opts)...)
                }
                allErrs = append(allErrs, unversionedvalidation.ValidateLabels(template.Labels, fldPath.Child("labels"))...)
                allErrs = append(allErrs, apivalidation.ValidateAnnotations(template.Annotations, fldPath.Child("annotations"))...)
                allErrs = append(allErrs, apivalidation.ValidatePodSpecificAnnotations(template.Annotations, &template.Spec, fldPath.Child("annotations"), opts)...)
        }
        return allErrs
}

func ValidatePersistentVolumeClaimRetentionPolicyType(policy apps.PersistentVolumeClaimRetentionPolicyType, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        switch policy {
        case apps.RetainPersistentVolumeClaimRetentionPolicyType:
        case apps.DeletePersistentVolumeClaimRetentionPolicyType:
        default:
                allErrs = append(allErrs, field.NotSupported(fldPath, policy, []string{string(apps.RetainPersistentVolumeClaimRetentionPolicyType), string(apps.DeletePersistentVolumeClaimRetentionPolicyType)}))
        }
        return allErrs
}

func ValidatePersistentVolumeClaimRetentionPolicy(policy *apps.StatefulSetPersistentVolumeClaimRetentionPolicy, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        if policy != nil {
                allErrs = append(allErrs, ValidatePersistentVolumeClaimRetentionPolicyType(policy.WhenDeleted, fldPath.Child("whenDeleted"))...)
                allErrs = append(allErrs, ValidatePersistentVolumeClaimRetentionPolicyType(policy.WhenScaled, fldPath.Child("whenScaled"))...)
        }
        return allErrs
}

func volumesToAddForTemplates(spec *apps.StatefulSetSpec) map[string]api.Volume {
        volumes := make(map[string]api.Volume)
        templates := spec.VolumeClaimTemplates
        for i := range templates {
                volumes[templates[i].Name] = api.Volume{
                        Name: templates[i].Name,
                        VolumeSource: api.VolumeSource{
                                PersistentVolumeClaim: &api.PersistentVolumeClaimVolumeSource{
                                        ClaimName: templates[i].Name,
                                },
                        },
                }
        }
        return volumes
}

func validateVolumeClaimTemplates(volumeClaimTemplates []api.PersistentVolumeClaim, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        opts := apivalidation.ValidationOptionsForPersistentVolumeClaimCreate()
        for i, pvc := range volumeClaimTemplates {
                allErrs = append(allErrs, apivalidation.ValidatePersistentVolumeClaimSpec(&pvc.Spec, fldPath.Index(i).Child("spec"), opts)...)
        }
        return allErrs
}

// ValidateStatefulSetSpec tests if required fields in the StatefulSet spec are set.
func ValidateStatefulSetSpec(spec *apps.StatefulSetSpec, fldPath *field.Path, opts apivalidation.PodValidationOptions, setOpts StatefulSetValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        switch spec.PodManagementPolicy {
        case "":
                allErrs = append(allErrs, field.Required(fldPath.Child("podManagementPolicy"), ""))
        case apps.OrderedReadyPodManagement, apps.ParallelPodManagement:
        default:
                allErrs = append(allErrs, field.Invalid(fldPath.Child("podManagementPolicy"), spec.PodManagementPolicy, fmt.Sprintf("must be '%s' or '%s'", apps.OrderedReadyPodManagement, apps.ParallelPodManagement)))
        }

        switch spec.UpdateStrategy.Type {
        case "":
                allErrs = append(allErrs, field.Required(fldPath.Child("updateStrategy"), ""))
        case apps.OnDeleteStatefulSetStrategyType:
                if spec.UpdateStrategy.RollingUpdate != nil {
                        allErrs = append(
                                allErrs,
                                field.Invalid(
                                        fldPath.Child("updateStrategy").Child("rollingUpdate"),
                                        spec.UpdateStrategy.RollingUpdate,
                                        fmt.Sprintf("only allowed for updateStrategy '%s'", apps.RollingUpdateStatefulSetStrategyType)))
                }
        case apps.RollingUpdateStatefulSetStrategyType:
                if spec.UpdateStrategy.RollingUpdate != nil {
                        allErrs = append(allErrs, validateRollingUpdateStatefulSet(spec.UpdateStrategy.RollingUpdate, fldPath.Child("updateStrategy", "rollingUpdate"))...)

                }
        default:
                allErrs = append(allErrs,
                        field.Invalid(fldPath.Child("updateStrategy"), spec.UpdateStrategy,
                                fmt.Sprintf("must be '%s' or '%s'",
                                        apps.RollingUpdateStatefulSetStrategyType,
                                        apps.OnDeleteStatefulSetStrategyType)))
        }

        allErrs = append(allErrs, ValidatePersistentVolumeClaimRetentionPolicy(spec.PersistentVolumeClaimRetentionPolicy, fldPath.Child("persistentVolumeClaimRetentionPolicy"))...)
        if !setOpts.SkipValidateVolumeClaimTemplates {
                allErrs = append(allErrs, validateVolumeClaimTemplates(spec.VolumeClaimTemplates, fldPath.Child("volumeClaimTemplates"))...)
        }

        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.Replicas), fldPath.Child("replicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.MinReadySeconds), fldPath.Child("minReadySeconds"))...)
        if spec.Ordinals != nil {
                replicaStartOrdinal := spec.Ordinals.Start
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(replicaStartOrdinal), fldPath.Child("ordinals.start"))...)
        }

        if !setOpts.AllowInvalidServiceName && len(spec.ServiceName) > 0 {
                allErrs = append(allErrs, apivalidation.ValidateDNS1123Label(spec.ServiceName, fldPath.Child("serviceName"))...)
        }

        if spec.Selector == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("selector"), ""))
        } else {
                // validate selector strictly, spec.selector was always required to pass LabelSelectorAsSelector below
                allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, unversionedvalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: false}, fldPath.Child("selector"))...)
                if len(spec.Selector.MatchLabels)+len(spec.Selector.MatchExpressions) == 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "empty selector is invalid for statefulset"))
                }
        }

        selector, err := metav1.LabelSelectorAsSelector(spec.Selector)
        if err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, ""))
        } else {
                templateToValidate := &spec.Template
                if len(spec.Template.Spec.Subdomain) > 0 || len(spec.Template.Spec.Hostname) > 0 || len(spec.VolumeClaimTemplates) > 0 {
                        templateToValidate = templateToValidate.DeepCopy()
                        // overwritten by controller to spec.ServiceName in initIdentity, don't validate
                        templateToValidate.Spec.Subdomain = ""
                        // overwritten by controller to pod.Name in initIdentity, don't validate
                        templateToValidate.Spec.Hostname = ""
                        if len(spec.VolumeClaimTemplates) > 0 {
                                templateVolumes := volumesToAddForTemplates(spec)
                                newVolumes := make([]api.Volume, 0, len(templateVolumes))
                                for _, v := range templateVolumes {
                                        newVolumes = append(newVolumes, v)
                                }
                                for _, v := range templateToValidate.Spec.Volumes {
                                        if _, ok := templateVolumes[v.Name]; !ok {
                                                newVolumes = append(newVolumes, v)
                                        }
                                }
                                templateToValidate.Spec.Volumes = newVolumes
                        }
                }
                allErrs = append(allErrs, ValidatePodTemplateSpecForStatefulSet(templateToValidate, selector, fldPath.Child("template"), opts, setOpts)...)
        }

        if spec.Template.Spec.RestartPolicy != api.RestartPolicyAlways {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("template", "spec", "restartPolicy"), spec.Template.Spec.RestartPolicy, []string{string(api.RestartPolicyAlways)}))
        }
        if spec.Template.Spec.ActiveDeadlineSeconds != nil {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("template", "spec", "activeDeadlineSeconds"), "activeDeadlineSeconds in StatefulSet is not Supported"))
        }

        return allErrs
}

// ValidateStatefulSet validates a StatefulSet.
func ValidateStatefulSet(statefulSet *apps.StatefulSet, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMeta(&statefulSet.ObjectMeta, true, ValidateStatefulSetName, field.NewPath("metadata"))
        setOpts := StatefulSetValidationOptions{
                AllowInvalidServiceName: false, // require valid serviceNames in new StatefulSets
        }
        allErrs = append(allErrs, ValidateStatefulSetSpec(&statefulSet.Spec, field.NewPath("spec"), opts, setOpts)...)
        return allErrs
}

// ValidateStatefulSetUpdate tests if required fields in the StatefulSet are set.
func ValidateStatefulSetUpdate(statefulSet, oldStatefulSet *apps.StatefulSet, opts apivalidation.PodValidationOptions) field.ErrorList {
        // First, validate that the new statefulset is valid.  Don't call
        // ValidateStatefulSet() because we don't want to revalidate the name on
        // update.  This is important here because we used to allow DNS subdomain
        // for name, but that can't actually create pods.  The only reasonable
        // thing to do it delete such an instance, but if there is a finalizer, it
        // would need to pass update validation.  Name can't change anyway.
        allErrs := apivalidation.ValidateObjectMetaUpdate(&statefulSet.ObjectMeta, &oldStatefulSet.ObjectMeta, field.NewPath("metadata"))
        setOpts := StatefulSetValidationOptions{
                AllowInvalidServiceName:          true, // serviceName is immutable, tolerate existing invalid names on update
                SkipValidateVolumeClaimTemplates: true, // volumeClaimTemplates are immutable, tolerate previously persisted invalid values on update
        }
        // In order to tolerate the existing sts, we choose to skip the validation error of old sts podTemplateSpec.
        if len(ValidateStatefulSetSpec(&oldStatefulSet.Spec, nil, opts, setOpts)) > 0 {
                setOpts.SkipValidatePodTemplateSpec = true
        }
        allErrs = append(allErrs, ValidateStatefulSetSpec(&statefulSet.Spec, field.NewPath("spec"), opts, setOpts)...)

        // statefulset updates aren't super common and general updates are likely to be touching spec, so we'll do this
        // deep copy right away.  This avoids mutating our inputs
        newStatefulSetClone := statefulSet.DeepCopy()
        newStatefulSetClone.Spec.Replicas = oldStatefulSet.Spec.Replicas                         // +k8s:verify-mutation:reason=clone
        newStatefulSetClone.Spec.Template = oldStatefulSet.Spec.Template                         // +k8s:verify-mutation:reason=clone
        newStatefulSetClone.Spec.UpdateStrategy = oldStatefulSet.Spec.UpdateStrategy             // +k8s:verify-mutation:reason=clone
        newStatefulSetClone.Spec.MinReadySeconds = oldStatefulSet.Spec.MinReadySeconds           // +k8s:verify-mutation:reason=clone
        newStatefulSetClone.Spec.Ordinals = oldStatefulSet.Spec.Ordinals                         // +k8s:verify-mutation:reason=clone
        newStatefulSetClone.Spec.RevisionHistoryLimit = oldStatefulSet.Spec.RevisionHistoryLimit // +k8s:verify-mutation:reason=clone

        newStatefulSetClone.Spec.PersistentVolumeClaimRetentionPolicy = oldStatefulSet.Spec.PersistentVolumeClaimRetentionPolicy // +k8s:verify-mutation:reason=clone
        if !apiequality.Semantic.DeepEqual(newStatefulSetClone.Spec, oldStatefulSet.Spec) {
                allErrs = append(allErrs, field.Forbidden(field.NewPath("spec"), "updates to statefulset spec for fields other than 'replicas', 'ordinals', 'template', 'updateStrategy', 'revisionHistoryLimit', 'persistentVolumeClaimRetentionPolicy' and 'minReadySeconds' are forbidden"))
        }

        return allErrs
}

// ValidateStatefulSetStatus validates a StatefulSetStatus.
func ValidateStatefulSetStatus(status *apps.StatefulSetStatus, fieldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.Replicas), fieldPath.Child("replicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.ReadyReplicas), fieldPath.Child("readyReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.CurrentReplicas), fieldPath.Child("currentReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.UpdatedReplicas), fieldPath.Child("updatedReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.AvailableReplicas), fieldPath.Child("availableReplicas"))...)
        if status.ObservedGeneration != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*status.ObservedGeneration), fieldPath.Child("observedGeneration"))...)
        }
        if status.CollisionCount != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*status.CollisionCount), fieldPath.Child("collisionCount"))...)
        }

        msg := "cannot be greater than status.replicas"
        if status.ReadyReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fieldPath.Child("readyReplicas"), status.ReadyReplicas, msg))
        }
        if status.CurrentReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fieldPath.Child("currentReplicas"), status.CurrentReplicas, msg))
        }
        if status.UpdatedReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fieldPath.Child("updatedReplicas"), status.UpdatedReplicas, msg))
        }
        if status.AvailableReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fieldPath.Child("availableReplicas"), status.AvailableReplicas, msg))
        }
        if status.AvailableReplicas > status.ReadyReplicas {
                allErrs = append(allErrs, field.Invalid(fieldPath.Child("availableReplicas"), status.AvailableReplicas, "cannot be greater than status.readyReplicas"))
        }
        return allErrs
}

// ValidateStatefulSetStatusUpdate tests if required fields in the StatefulSet are set.
func ValidateStatefulSetStatusUpdate(statefulSet, oldStatefulSet *apps.StatefulSet) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateStatefulSetStatus(&statefulSet.Status, field.NewPath("status"))...)
        allErrs = append(allErrs, apivalidation.ValidateObjectMetaUpdate(&statefulSet.ObjectMeta, &oldStatefulSet.ObjectMeta, field.NewPath("metadata"))...)
        // TODO: Validate status.
        if apivalidation.IsDecremented(statefulSet.Status.CollisionCount, oldStatefulSet.Status.CollisionCount) {
                value := int32(0)
                if statefulSet.Status.CollisionCount != nil {
                        value = *statefulSet.Status.CollisionCount
                }
                allErrs = append(allErrs, field.Invalid(field.NewPath("status").Child("collisionCount"), value, "cannot be decremented"))
        }
        return allErrs
}

// ValidateControllerRevisionName can be used to check whether the given ControllerRevision name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateControllerRevisionName = apimachineryvalidation.NameIsDNSSubdomain

// validateControllerRevision collects errors for the fields of state and returns those errors as an ErrorList. If the
// returned list is empty, state is valid. Validation is performed to ensure that state is a valid ObjectMeta, its name
// is valid, and that it doesn't exceed the MaxControllerRevisionSize.
func validateControllerRevision(revision *apps.ControllerRevision) field.ErrorList {
        errs := field.ErrorList{}
        errs = append(errs, apivalidation.ValidateObjectMeta(&revision.ObjectMeta, true, ValidateControllerRevisionName, field.NewPath("metadata"))...)
        errs = append(errs, apivalidation.ValidateNonnegativeField(revision.Revision, field.NewPath("revision"))...)
        return errs
}

func ValidateControllerRevisionCreate(revision *apps.ControllerRevision) field.ErrorList {
        errs := field.ErrorList{}
        errs = append(errs, validateControllerRevision(revision)...)

        var v any
        if revision.Data.Raw == nil {
                errs = append(errs, field.Required(field.NewPath("data"), "data is mandatory"))
        } else if err := json.Unmarshal(revision.Data.Raw, &v); err != nil {
                errs = append(errs, field.Invalid(field.NewPath("data"), "<value omitted>", fmt.Sprintf("error parsing data: %v", err.Error())))
        } else if v == nil {
                errs = append(errs, field.Required(field.NewPath("data"), "data is mandatory"))
        } else if _, isObject := v.(map[string]any); !isObject {
                errs = append(errs, field.Required(field.NewPath("data"), "data must be a valid JSON object"))
        }

        return errs
}

// ValidateControllerRevisionUpdate collects errors pertaining to the mutation of an ControllerRevision Object. If the
// returned ErrorList is empty the update operation is valid. Any mutation to the ControllerRevision's Data or Revision
// is considered to be invalid.
func ValidateControllerRevisionUpdate(newHistory, oldHistory *apps.ControllerRevision) field.ErrorList {
        errs := field.ErrorList{}

        errs = append(errs, apivalidation.ValidateObjectMetaUpdate(&newHistory.ObjectMeta, &oldHistory.ObjectMeta, field.NewPath("metadata"))...)
        errs = append(errs, validateControllerRevision(newHistory)...)
        errs = append(errs, apivalidation.ValidateImmutableField(newHistory.Data, oldHistory.Data, field.NewPath("data"))...)
        return errs
}

// ValidateDaemonSet tests if required fields in the DaemonSet are set.
func ValidateDaemonSet(ds *apps.DaemonSet, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMeta(&ds.ObjectMeta, true, ValidateDaemonSetName, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateDaemonSetSpec(&ds.Spec, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateDaemonSetUpdate tests if required fields in the DaemonSet are set.
func ValidateDaemonSetUpdate(ds, oldDS *apps.DaemonSet, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&ds.ObjectMeta, &oldDS.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateDaemonSetSpecUpdate(&ds.Spec, &oldDS.Spec, field.NewPath("spec"))...)
        allErrs = append(allErrs, ValidateDaemonSetSpec(&ds.Spec, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateDaemonSetSpecUpdate tests if an update to a DaemonSetSpec is valid.
func ValidateDaemonSetSpecUpdate(newSpec, oldSpec *apps.DaemonSetSpec, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        // TemplateGeneration shouldn't be decremented
        if newSpec.TemplateGeneration < oldSpec.TemplateGeneration {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("templateGeneration"), newSpec.TemplateGeneration, "must not be decremented"))
        }

        // TemplateGeneration should be increased when and only when template is changed
        templateUpdated := !apiequality.Semantic.DeepEqual(newSpec.Template, oldSpec.Template)
        if newSpec.TemplateGeneration == oldSpec.TemplateGeneration && templateUpdated {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("templateGeneration"), newSpec.TemplateGeneration, "must be incremented upon template update"))
        } else if newSpec.TemplateGeneration > oldSpec.TemplateGeneration && !templateUpdated {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("templateGeneration"), newSpec.TemplateGeneration, "must not be incremented without template update"))
        }

        // Spec.Selector is immutable
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(newSpec.Selector, oldSpec.Selector, field.NewPath("spec").Child("selector"))...)

        return allErrs
}

// validateDaemonSetStatus validates a DaemonSetStatus
func validateDaemonSetStatus(status *apps.DaemonSetStatus, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.CurrentNumberScheduled), fldPath.Child("currentNumberScheduled"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.NumberMisscheduled), fldPath.Child("numberMisscheduled"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.DesiredNumberScheduled), fldPath.Child("desiredNumberScheduled"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.NumberReady), fldPath.Child("numberReady"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(status.ObservedGeneration, fldPath.Child("observedGeneration"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.UpdatedNumberScheduled), fldPath.Child("updatedNumberScheduled"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.NumberAvailable), fldPath.Child("numberAvailable"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.NumberUnavailable), fldPath.Child("numberUnavailable"))...)
        if status.CollisionCount != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*status.CollisionCount), fldPath.Child("collisionCount"))...)
        }
        return allErrs
}

// ValidateDaemonSetStatusUpdate tests if required fields in the DaemonSet Status section
func ValidateDaemonSetStatusUpdate(ds, oldDS *apps.DaemonSet) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&ds.ObjectMeta, &oldDS.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, validateDaemonSetStatus(&ds.Status, field.NewPath("status"))...)
        if apivalidation.IsDecremented(ds.Status.CollisionCount, oldDS.Status.CollisionCount) {
                value := int32(0)
                if ds.Status.CollisionCount != nil {
                        value = *ds.Status.CollisionCount
                }
                allErrs = append(allErrs, field.Invalid(field.NewPath("status").Child("collisionCount"), value, "cannot be decremented"))
        }
        return allErrs
}

// ValidateDaemonSetSpec tests if required fields in the DaemonSetSpec are set.
func ValidateDaemonSetSpec(spec *apps.DaemonSetSpec, fldPath *field.Path, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        labelSelectorValidationOpts := unversionedvalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: opts.AllowInvalidLabelValueInSelector}

        allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, labelSelectorValidationOpts, fldPath.Child("selector"))...)

        selector, err := metav1.LabelSelectorAsSelector(spec.Selector)
        if err == nil && !selector.Matches(labels.Set(spec.Template.Labels)) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("template", "metadata", "labels"), spec.Template.Labels, "`selector` does not match template `labels`"))
        }
        if spec.Selector != nil && len(spec.Selector.MatchLabels)+len(spec.Selector.MatchExpressions) == 0 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "empty selector is invalid for daemonset"))
        }

        allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpec(&spec.Template, fldPath.Child("template"), opts)...)
        // RestartPolicy has already been first-order validated as per ValidatePodTemplateSpec().
        if spec.Template.Spec.RestartPolicy != api.RestartPolicyAlways {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("template", "spec", "restartPolicy"), spec.Template.Spec.RestartPolicy, []string{string(api.RestartPolicyAlways)}))
        }
        if spec.Template.Spec.ActiveDeadlineSeconds != nil {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("template", "spec", "activeDeadlineSeconds"), "activeDeadlineSeconds in DaemonSet is not Supported"))
        }
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.MinReadySeconds), fldPath.Child("minReadySeconds"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.TemplateGeneration), fldPath.Child("templateGeneration"))...)

        allErrs = append(allErrs, ValidateDaemonSetUpdateStrategy(&spec.UpdateStrategy, fldPath.Child("updateStrategy"))...)
        if spec.RevisionHistoryLimit != nil {
                // zero is a valid RevisionHistoryLimit
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.RevisionHistoryLimit), fldPath.Child("revisionHistoryLimit"))...)
        }
        return allErrs
}

// ValidateRollingUpdateDaemonSet validates a given RollingUpdateDaemonSet.
func ValidateRollingUpdateDaemonSet(rollingUpdate *apps.RollingUpdateDaemonSet, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList

        // Validate both fields are positive ints or have a percentage value
        allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
        allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxSurge, fldPath.Child("maxSurge"))...)

        // Validate that MaxUnavailable and MaxSurge are not more than 100%.
        allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
        allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxSurge, fldPath.Child("maxSurge"))...)

        // Validate exactly one of MaxSurge or MaxUnavailable is non-zero
        hasUnavailable := getIntOrPercentValue(rollingUpdate.MaxUnavailable) != 0
        hasSurge := getIntOrPercentValue(rollingUpdate.MaxSurge) != 0
        switch {
        case hasUnavailable && hasSurge:
                allErrs = append(allErrs, field.Invalid(fldPath.Child("maxSurge"), rollingUpdate.MaxSurge, "may not be set when maxUnavailable is non-zero"))
        case !hasUnavailable && !hasSurge:
                allErrs = append(allErrs, field.Required(fldPath.Child("maxUnavailable"), "cannot be 0 when maxSurge is 0"))
        }

        return allErrs
}

// validateRollingUpdateStatefulSet validates a given RollingUpdateStatefulSet.
func validateRollingUpdateStatefulSet(rollingUpdate *apps.RollingUpdateStatefulSetStrategy, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        fldPathMaxUn := fldPath.Child("maxUnavailable")
        allErrs = append(allErrs,
                apivalidation.ValidateNonnegativeField(
                        int64(rollingUpdate.Partition),
                        fldPath.Child("partition"))...)
        if rollingUpdate.MaxUnavailable != nil {
                allErrs = append(allErrs, ValidatePositiveIntOrPercent(*rollingUpdate.MaxUnavailable, fldPathMaxUn)...)
                if getIntOrPercentValue(*rollingUpdate.MaxUnavailable) == 0 {
                        // MaxUnavailable cannot be 0.
                        allErrs = append(allErrs, field.Invalid(fldPathMaxUn, *rollingUpdate.MaxUnavailable, "cannot be 0"))
                }
                // Validate that MaxUnavailable is not more than 100%.
                allErrs = append(allErrs, IsNotMoreThan100Percent(*rollingUpdate.MaxUnavailable, fldPathMaxUn)...)
        }
        return allErrs
}

// ValidateDaemonSetUpdateStrategy validates a given DaemonSetUpdateStrategy.
func ValidateDaemonSetUpdateStrategy(strategy *apps.DaemonSetUpdateStrategy, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        switch strategy.Type {
        case apps.OnDeleteDaemonSetStrategyType:
        case apps.RollingUpdateDaemonSetStrategyType:
                // Make sure RollingUpdate field isn't nil.
                if strategy.RollingUpdate == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("rollingUpdate"), ""))
                        return allErrs
                }
                allErrs = append(allErrs, ValidateRollingUpdateDaemonSet(strategy.RollingUpdate, fldPath.Child("rollingUpdate"))...)
        default:
                validValues := []string{string(apps.RollingUpdateDaemonSetStrategyType), string(apps.OnDeleteDaemonSetStrategyType)}
                allErrs = append(allErrs, field.NotSupported(fldPath, strategy, validValues))
        }
        return allErrs
}

// ValidateDaemonSetName can be used to check whether the given daemon set name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateDaemonSetName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateDeploymentName validates that the given name can be used as a deployment name.
var ValidateDeploymentName = apimachineryvalidation.NameIsDNSSubdomain

// ValidatePositiveIntOrPercent tests if a given value is a valid int or
// percentage.
func ValidatePositiveIntOrPercent(intOrPercent intstr.IntOrString, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        switch intOrPercent.Type {
        case intstr.String:
                for _, msg := range validation.IsValidPercent(intOrPercent.StrVal) {
                        allErrs = append(allErrs, field.Invalid(fldPath, intOrPercent, msg))
                }
        case intstr.Int:
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(intOrPercent.IntValue()), fldPath)...)
        default:
                allErrs = append(allErrs, field.Invalid(fldPath, intOrPercent, "must be an integer or percentage (e.g '5%%')"))
        }
        return allErrs
}

func getPercentValue(intOrStringValue intstr.IntOrString) (int, bool) {
        if intOrStringValue.Type != intstr.String {
                return 0, false
        }
        if len(validation.IsValidPercent(intOrStringValue.StrVal)) != 0 {
                return 0, false
        }
        value, _ := strconv.Atoi(intOrStringValue.StrVal[:len(intOrStringValue.StrVal)-1])
        return value, true
}

func getIntOrPercentValue(intOrStringValue intstr.IntOrString) int {
        value, isPercent := getPercentValue(intOrStringValue)
        if isPercent {
                return value
        }
        return intOrStringValue.IntValue()
}

// IsNotMoreThan100Percent tests is a value can be represented as a percentage
// and if this value is not more than 100%.
func IsNotMoreThan100Percent(intOrStringValue intstr.IntOrString, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        value, isPercent := getPercentValue(intOrStringValue)
        if !isPercent || value <= 100 {
                return nil
        }
        allErrs = append(allErrs, field.Invalid(fldPath, intOrStringValue, "must not be greater than 100%"))
        return allErrs
}

// ValidateRollingUpdateDeployment validates a given RollingUpdateDeployment.
func ValidateRollingUpdateDeployment(rollingUpdate *apps.RollingUpdateDeployment, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
        allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxSurge, fldPath.Child("maxSurge"))...)
        if getIntOrPercentValue(rollingUpdate.MaxUnavailable) == 0 && getIntOrPercentValue(rollingUpdate.MaxSurge) == 0 {
                // Both MaxSurge and MaxUnavailable cannot be zero.
                allErrs = append(allErrs, field.Invalid(fldPath.Child("maxUnavailable"), rollingUpdate.MaxUnavailable, "may not be 0 when `maxSurge` is 0"))
        }
        // Validate that MaxUnavailable is not more than 100%.
        allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
        return allErrs
}

// ValidateDeploymentStrategy validates given DeploymentStrategy.
func ValidateDeploymentStrategy(strategy *apps.DeploymentStrategy, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        switch strategy.Type {
        case apps.RecreateDeploymentStrategyType:
                if strategy.RollingUpdate != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("rollingUpdate"), "may not be specified when strategy `type` is '"+string(apps.RecreateDeploymentStrategyType+"'")))
                }
        case apps.RollingUpdateDeploymentStrategyType:
                // This should never happen since it's set and checked in defaults.go
                if strategy.RollingUpdate == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("rollingUpdate"), "this should be defaulted and never be nil"))
                } else {
                        allErrs = append(allErrs, ValidateRollingUpdateDeployment(strategy.RollingUpdate, fldPath.Child("rollingUpdate"))...)
                }
        default:
                validValues := []string{string(apps.RecreateDeploymentStrategyType), string(apps.RollingUpdateDeploymentStrategyType)}
                allErrs = append(allErrs, field.NotSupported(fldPath, strategy, validValues))
        }
        return allErrs
}

// ValidateRollback validates given RollbackConfig.
func ValidateRollback(rollback *apps.RollbackConfig, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        v := rollback.Revision
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(v), fldPath.Child("version"))...)
        return allErrs
}

// ValidateDeploymentSpec validates given deployment spec.
func ValidateDeploymentSpec(spec, oldSpec *apps.DeploymentSpec, fldPath *field.Path, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.Replicas), fldPath.Child("replicas"))...)

        if spec.Selector == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("selector"), ""))
        } else {
                // validate selector strictly, spec.selector was always required to pass LabelSelectorAsSelector below
                allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, unversionedvalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: false}, fldPath.Child("selector"))...)
                if len(spec.Selector.MatchLabels)+len(spec.Selector.MatchExpressions) == 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "empty selector is invalid for deployment"))
                }
        }

        selector, err := metav1.LabelSelectorAsSelector(spec.Selector)
        if err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "invalid label selector"))
        } else {
                allErrs = append(allErrs, ValidatePodTemplateSpecForReplicaSet(&spec.Template, selector, spec.Replicas, fldPath.Child("template"), opts)...)
        }

        allErrs = append(allErrs, ValidateDeploymentStrategy(&spec.Strategy, fldPath.Child("strategy"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.MinReadySeconds), fldPath.Child("minReadySeconds"))...)
        if spec.RevisionHistoryLimit != nil {
                // zero is a valid RevisionHistoryLimit
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.RevisionHistoryLimit), fldPath.Child("revisionHistoryLimit"))...)
        }
        if spec.RollbackTo != nil {
                allErrs = append(allErrs, ValidateRollback(spec.RollbackTo, fldPath.Child("rollback"))...)
        }
        if spec.ProgressDeadlineSeconds != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.ProgressDeadlineSeconds), fldPath.Child("progressDeadlineSeconds"))...)
                if *spec.ProgressDeadlineSeconds <= spec.MinReadySeconds {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("progressDeadlineSeconds"), spec.ProgressDeadlineSeconds, "must be greater than minReadySeconds"))
                }
        }
        return allErrs
}

// ValidateDeploymentStatus validates given deployment status.
func ValidateDeploymentStatus(status *apps.DeploymentStatus, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(status.ObservedGeneration, fldPath.Child("observedGeneration"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.Replicas), fldPath.Child("replicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.UpdatedReplicas), fldPath.Child("updatedReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.ReadyReplicas), fldPath.Child("readyReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.AvailableReplicas), fldPath.Child("availableReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.UnavailableReplicas), fldPath.Child("unavailableReplicas"))...)
        if status.TerminatingReplicas != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*status.TerminatingReplicas), fldPath.Child("terminatingReplicas"))...)
        }
        if status.CollisionCount != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*status.CollisionCount), fldPath.Child("collisionCount"))...)
        }
        msg := "cannot be greater than status.replicas"
        if status.UpdatedReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("updatedReplicas"), status.UpdatedReplicas, msg))
        }
        if status.ReadyReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("readyReplicas"), status.ReadyReplicas, msg))
        }
        if status.AvailableReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("availableReplicas"), status.AvailableReplicas, msg))
        }
        if status.AvailableReplicas > status.ReadyReplicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("availableReplicas"), status.AvailableReplicas, "cannot be greater than readyReplicas"))
        }
        return allErrs
}

// ValidateDeploymentUpdate tests if an update to a Deployment is valid.
func ValidateDeploymentUpdate(update, old *apps.Deployment, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&update.ObjectMeta, &old.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateDeploymentSpec(&update.Spec, &old.Spec, field.NewPath("spec"), opts)...)
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(update.Spec.Selector, old.Spec.Selector, field.NewPath("spec").Child("selector"))...)
        return allErrs
}

// ValidateDeploymentStatusUpdate tests if a an update to a Deployment status
// is valid.
func ValidateDeploymentStatusUpdate(update, old *apps.Deployment) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&update.ObjectMeta, &old.ObjectMeta, field.NewPath("metadata"))
        fldPath := field.NewPath("status")
        allErrs = append(allErrs, ValidateDeploymentStatus(&update.Status, fldPath)...)
        if apivalidation.IsDecremented(update.Status.CollisionCount, old.Status.CollisionCount) {
                value := int32(0)
                if update.Status.CollisionCount != nil {
                        value = *update.Status.CollisionCount
                }
                allErrs = append(allErrs, field.Invalid(fldPath.Child("collisionCount"), value, "cannot be decremented"))
        }
        return allErrs
}

// ValidateDeployment validates a given Deployment.
func ValidateDeployment(obj *apps.Deployment, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMeta(&obj.ObjectMeta, true, ValidateDeploymentName, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateDeploymentSpec(&obj.Spec, nil, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateDeploymentRollback validates a given DeploymentRollback.
func ValidateDeploymentRollback(obj *apps.DeploymentRollback) field.ErrorList {
        allErrs := apivalidation.ValidateAnnotations(obj.UpdatedAnnotations, field.NewPath("updatedAnnotations"))
        if len(obj.Name) == 0 {
                allErrs = append(allErrs, field.Required(field.NewPath("name"), ""))
        }
        allErrs = append(allErrs, ValidateRollback(&obj.RollbackTo, field.NewPath("rollback"))...)
        return allErrs
}

// ValidateReplicaSetName can be used to check whether the given ReplicaSet
// name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateReplicaSetName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateReplicaSet tests if required fields in the ReplicaSet are set.
func ValidateReplicaSet(rs *apps.ReplicaSet, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMeta(&rs.ObjectMeta, true, ValidateReplicaSetName, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateReplicaSetSpec(&rs.Spec, nil, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateReplicaSetUpdate tests if required fields in the ReplicaSet are set.
func ValidateReplicaSetUpdate(rs, oldRs *apps.ReplicaSet, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, apivalidation.ValidateObjectMetaUpdate(&rs.ObjectMeta, &oldRs.ObjectMeta, field.NewPath("metadata"))...)
        allErrs = append(allErrs, ValidateReplicaSetSpec(&rs.Spec, &oldRs.Spec, field.NewPath("spec"), opts)...)
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(rs.Spec.Selector, oldRs.Spec.Selector, field.NewPath("spec").Child("selector"))...)
        return allErrs
}

// ValidateReplicaSetStatusUpdate tests if required fields in the ReplicaSet are set.
func ValidateReplicaSetStatusUpdate(rs, oldRs *apps.ReplicaSet) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, apivalidation.ValidateObjectMetaUpdate(&rs.ObjectMeta, &oldRs.ObjectMeta, field.NewPath("metadata"))...)
        allErrs = append(allErrs, ValidateReplicaSetStatus(rs.Status, field.NewPath("status"))...)
        return allErrs
}

// ValidateReplicaSetStatus validates a given ReplicaSetStatus.
func ValidateReplicaSetStatus(status apps.ReplicaSetStatus, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.Replicas), fldPath.Child("replicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.FullyLabeledReplicas), fldPath.Child("fullyLabeledReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.ReadyReplicas), fldPath.Child("readyReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.AvailableReplicas), fldPath.Child("availableReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.ObservedGeneration), fldPath.Child("observedGeneration"))...)
        if status.TerminatingReplicas != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*status.TerminatingReplicas), fldPath.Child("terminatingReplicas"))...)
        }
        msg := "cannot be greater than status.replicas"
        if status.FullyLabeledReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("fullyLabeledReplicas"), status.FullyLabeledReplicas, msg))
        }
        if status.ReadyReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("readyReplicas"), status.ReadyReplicas, msg))
        }
        if status.AvailableReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("availableReplicas"), status.AvailableReplicas, msg))
        }
        if status.AvailableReplicas > status.ReadyReplicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("availableReplicas"), status.AvailableReplicas, "cannot be greater than readyReplicas"))
        }
        return allErrs
}

// ValidateReplicaSetSpec tests if required fields in the ReplicaSet spec are set.
func ValidateReplicaSetSpec(spec, oldSpec *apps.ReplicaSetSpec, fldPath *field.Path, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.Replicas), fldPath.Child("replicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(spec.MinReadySeconds), fldPath.Child("minReadySeconds"))...)

        if spec.Selector == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("selector"), ""))
        } else {
                // validate selector strictly, spec.selector was always required to pass LabelSelectorAsSelector below
                allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, unversionedvalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: false}, fldPath.Child("selector"))...)
                if len(spec.Selector.MatchLabels)+len(spec.Selector.MatchExpressions) == 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "empty selector is invalid for deployment"))
                }
        }

        selector, err := metav1.LabelSelectorAsSelector(spec.Selector)
        if err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("selector"), spec.Selector, "invalid label selector"))
        } else {
                allErrs = append(allErrs, ValidatePodTemplateSpecForReplicaSet(&spec.Template, selector, spec.Replicas, fldPath.Child("template"), opts)...)
        }
        return allErrs
}

// ValidatePodTemplateSpecForReplicaSet validates the given template and ensures that it is in accordance with the desired selector and replicas.
func ValidatePodTemplateSpecForReplicaSet(template *api.PodTemplateSpec, selector labels.Selector, replicas int32, fldPath *field.Path, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if template == nil {
                allErrs = append(allErrs, field.Required(fldPath, ""))
        } else {
                if !selector.Empty() {
                        // Verify that the ReplicaSet selector matches the labels in template.
                        labels := labels.Set(template.Labels)
                        if !selector.Matches(labels) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("metadata", "labels"), template.Labels, "`selector` does not match template `labels`"))
                        }
                }
                allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpec(template, fldPath, opts)...)
                // RestartPolicy has already been first-order validated as per ValidatePodTemplateSpec().
                if template.Spec.RestartPolicy != api.RestartPolicyAlways {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("spec", "restartPolicy"), template.Spec.RestartPolicy, []string{string(api.RestartPolicyAlways)}))
                }
                if template.Spec.ActiveDeadlineSeconds != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("spec", "activeDeadlineSeconds"), "activeDeadlineSeconds in ReplicaSet is not Supported"))
                }
        }
        return allErrs
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package apps

import (
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        intstr "k8s.io/apimachinery/pkg/util/intstr"
        core "k8s.io/kubernetes/pkg/apis/core"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ControllerRevision) DeepCopyInto(out *ControllerRevision) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Data.DeepCopyInto(&out.Data)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ControllerRevision.
func (in *ControllerRevision) DeepCopy() *ControllerRevision {
        if in == nil {
                return nil
        }
        out := new(ControllerRevision)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ControllerRevision) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ControllerRevisionList) DeepCopyInto(out *ControllerRevisionList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ControllerRevision, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ControllerRevisionList.
func (in *ControllerRevisionList) DeepCopy() *ControllerRevisionList {
        if in == nil {
                return nil
        }
        out := new(ControllerRevisionList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ControllerRevisionList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DaemonSet) DeepCopyInto(out *DaemonSet) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonSet.
func (in *DaemonSet) DeepCopy() *DaemonSet {
        if in == nil {
                return nil
        }
        out := new(DaemonSet)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *DaemonSet) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DaemonSetCondition) DeepCopyInto(out *DaemonSetCondition) {
        *out = *in
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonSetCondition.
func (in *DaemonSetCondition) DeepCopy() *DaemonSetCondition {
        if in == nil {
                return nil
        }
        out := new(DaemonSetCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DaemonSetList) DeepCopyInto(out *DaemonSetList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]DaemonSet, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonSetList.
func (in *DaemonSetList) DeepCopy() *DaemonSetList {
        if in == nil {
                return nil
        }
        out := new(DaemonSetList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *DaemonSetList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DaemonSetSpec) DeepCopyInto(out *DaemonSetSpec) {
        *out = *in
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        in.Template.DeepCopyInto(&out.Template)
        in.UpdateStrategy.DeepCopyInto(&out.UpdateStrategy)
        if in.RevisionHistoryLimit != nil {
                in, out := &in.RevisionHistoryLimit, &out.RevisionHistoryLimit
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonSetSpec.
func (in *DaemonSetSpec) DeepCopy() *DaemonSetSpec {
        if in == nil {
                return nil
        }
        out := new(DaemonSetSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DaemonSetStatus) DeepCopyInto(out *DaemonSetStatus) {
        *out = *in
        if in.CollisionCount != nil {
                in, out := &in.CollisionCount, &out.CollisionCount
                *out = new(int32)
                **out = **in
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]DaemonSetCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonSetStatus.
func (in *DaemonSetStatus) DeepCopy() *DaemonSetStatus {
        if in == nil {
                return nil
        }
        out := new(DaemonSetStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DaemonSetUpdateStrategy) DeepCopyInto(out *DaemonSetUpdateStrategy) {
        *out = *in
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(RollingUpdateDaemonSet)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonSetUpdateStrategy.
func (in *DaemonSetUpdateStrategy) DeepCopy() *DaemonSetUpdateStrategy {
        if in == nil {
                return nil
        }
        out := new(DaemonSetUpdateStrategy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Deployment) DeepCopyInto(out *Deployment) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Deployment.
func (in *Deployment) DeepCopy() *Deployment {
        if in == nil {
                return nil
        }
        out := new(Deployment)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Deployment) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DeploymentCondition) DeepCopyInto(out *DeploymentCondition) {
        *out = *in
        in.LastUpdateTime.DeepCopyInto(&out.LastUpdateTime)
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeploymentCondition.
func (in *DeploymentCondition) DeepCopy() *DeploymentCondition {
        if in == nil {
                return nil
        }
        out := new(DeploymentCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DeploymentList) DeepCopyInto(out *DeploymentList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Deployment, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeploymentList.
func (in *DeploymentList) DeepCopy() *DeploymentList {
        if in == nil {
                return nil
        }
        out := new(DeploymentList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *DeploymentList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DeploymentRollback) DeepCopyInto(out *DeploymentRollback) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        if in.UpdatedAnnotations != nil {
                in, out := &in.UpdatedAnnotations, &out.UpdatedAnnotations
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        out.RollbackTo = in.RollbackTo
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeploymentRollback.
func (in *DeploymentRollback) DeepCopy() *DeploymentRollback {
        if in == nil {
                return nil
        }
        out := new(DeploymentRollback)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *DeploymentRollback) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DeploymentSpec) DeepCopyInto(out *DeploymentSpec) {
        *out = *in
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        in.Template.DeepCopyInto(&out.Template)
        in.Strategy.DeepCopyInto(&out.Strategy)
        if in.RevisionHistoryLimit != nil {
                in, out := &in.RevisionHistoryLimit, &out.RevisionHistoryLimit
                *out = new(int32)
                **out = **in
        }
        if in.RollbackTo != nil {
                in, out := &in.RollbackTo, &out.RollbackTo
                *out = new(RollbackConfig)
                **out = **in
        }
        if in.ProgressDeadlineSeconds != nil {
                in, out := &in.ProgressDeadlineSeconds, &out.ProgressDeadlineSeconds
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeploymentSpec.
func (in *DeploymentSpec) DeepCopy() *DeploymentSpec {
        if in == nil {
                return nil
        }
        out := new(DeploymentSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DeploymentStatus) DeepCopyInto(out *DeploymentStatus) {
        *out = *in
        if in.TerminatingReplicas != nil {
                in, out := &in.TerminatingReplicas, &out.TerminatingReplicas
                *out = new(int32)
                **out = **in
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]DeploymentCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.CollisionCount != nil {
                in, out := &in.CollisionCount, &out.CollisionCount
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeploymentStatus.
func (in *DeploymentStatus) DeepCopy() *DeploymentStatus {
        if in == nil {
                return nil
        }
        out := new(DeploymentStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DeploymentStrategy) DeepCopyInto(out *DeploymentStrategy) {
        *out = *in
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(RollingUpdateDeployment)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DeploymentStrategy.
func (in *DeploymentStrategy) DeepCopy() *DeploymentStrategy {
        if in == nil {
                return nil
        }
        out := new(DeploymentStrategy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicaSet) DeepCopyInto(out *ReplicaSet) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicaSet.
func (in *ReplicaSet) DeepCopy() *ReplicaSet {
        if in == nil {
                return nil
        }
        out := new(ReplicaSet)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ReplicaSet) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicaSetCondition) DeepCopyInto(out *ReplicaSetCondition) {
        *out = *in
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicaSetCondition.
func (in *ReplicaSetCondition) DeepCopy() *ReplicaSetCondition {
        if in == nil {
                return nil
        }
        out := new(ReplicaSetCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicaSetList) DeepCopyInto(out *ReplicaSetList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ReplicaSet, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicaSetList.
func (in *ReplicaSetList) DeepCopy() *ReplicaSetList {
        if in == nil {
                return nil
        }
        out := new(ReplicaSetList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ReplicaSetList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicaSetSpec) DeepCopyInto(out *ReplicaSetSpec) {
        *out = *in
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        in.Template.DeepCopyInto(&out.Template)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicaSetSpec.
func (in *ReplicaSetSpec) DeepCopy() *ReplicaSetSpec {
        if in == nil {
                return nil
        }
        out := new(ReplicaSetSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicaSetStatus) DeepCopyInto(out *ReplicaSetStatus) {
        *out = *in
        if in.TerminatingReplicas != nil {
                in, out := &in.TerminatingReplicas, &out.TerminatingReplicas
                *out = new(int32)
                **out = **in
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]ReplicaSetCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicaSetStatus.
func (in *ReplicaSetStatus) DeepCopy() *ReplicaSetStatus {
        if in == nil {
                return nil
        }
        out := new(ReplicaSetStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RollbackConfig) DeepCopyInto(out *RollbackConfig) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RollbackConfig.
func (in *RollbackConfig) DeepCopy() *RollbackConfig {
        if in == nil {
                return nil
        }
        out := new(RollbackConfig)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RollingUpdateDaemonSet) DeepCopyInto(out *RollingUpdateDaemonSet) {
        *out = *in
        out.MaxUnavailable = in.MaxUnavailable
        out.MaxSurge = in.MaxSurge
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RollingUpdateDaemonSet.
func (in *RollingUpdateDaemonSet) DeepCopy() *RollingUpdateDaemonSet {
        if in == nil {
                return nil
        }
        out := new(RollingUpdateDaemonSet)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RollingUpdateDeployment) DeepCopyInto(out *RollingUpdateDeployment) {
        *out = *in
        out.MaxUnavailable = in.MaxUnavailable
        out.MaxSurge = in.MaxSurge
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RollingUpdateDeployment.
func (in *RollingUpdateDeployment) DeepCopy() *RollingUpdateDeployment {
        if in == nil {
                return nil
        }
        out := new(RollingUpdateDeployment)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RollingUpdateStatefulSetStrategy) DeepCopyInto(out *RollingUpdateStatefulSetStrategy) {
        *out = *in
        if in.MaxUnavailable != nil {
                in, out := &in.MaxUnavailable, &out.MaxUnavailable
                *out = new(intstr.IntOrString)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RollingUpdateStatefulSetStrategy.
func (in *RollingUpdateStatefulSetStrategy) DeepCopy() *RollingUpdateStatefulSetStrategy {
        if in == nil {
                return nil
        }
        out := new(RollingUpdateStatefulSetStrategy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StatefulSet) DeepCopyInto(out *StatefulSet) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSet.
func (in *StatefulSet) DeepCopy() *StatefulSet {
        if in == nil {
                return nil
        }
        out := new(StatefulSet)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *StatefulSet) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StatefulSetCondition) DeepCopyInto(out *StatefulSetCondition) {
        *out = *in
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetCondition.
func (in *StatefulSetCondition) DeepCopy() *StatefulSetCondition {
        if in == nil {
                return nil
        }
        out := new(StatefulSetCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StatefulSetList) DeepCopyInto(out *StatefulSetList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]StatefulSet, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetList.
func (in *StatefulSetList) DeepCopy() *StatefulSetList {
        if in == nil {
                return nil
        }
        out := new(StatefulSetList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *StatefulSetList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StatefulSetOrdinals) DeepCopyInto(out *StatefulSetOrdinals) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetOrdinals.
func (in *StatefulSetOrdinals) DeepCopy() *StatefulSetOrdinals {
        if in == nil {
                return nil
        }
        out := new(StatefulSetOrdinals)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StatefulSetPersistentVolumeClaimRetentionPolicy) DeepCopyInto(out *StatefulSetPersistentVolumeClaimRetentionPolicy) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetPersistentVolumeClaimRetentionPolicy.
func (in *StatefulSetPersistentVolumeClaimRetentionPolicy) DeepCopy() *StatefulSetPersistentVolumeClaimRetentionPolicy {
        if in == nil {
                return nil
        }
        out := new(StatefulSetPersistentVolumeClaimRetentionPolicy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StatefulSetSpec) DeepCopyInto(out *StatefulSetSpec) {
        *out = *in
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        in.Template.DeepCopyInto(&out.Template)
        if in.VolumeClaimTemplates != nil {
                in, out := &in.VolumeClaimTemplates, &out.VolumeClaimTemplates
                *out = make([]core.PersistentVolumeClaim, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        in.UpdateStrategy.DeepCopyInto(&out.UpdateStrategy)
        if in.RevisionHistoryLimit != nil {
                in, out := &in.RevisionHistoryLimit, &out.RevisionHistoryLimit
                *out = new(int32)
                **out = **in
        }
        if in.PersistentVolumeClaimRetentionPolicy != nil {
                in, out := &in.PersistentVolumeClaimRetentionPolicy, &out.PersistentVolumeClaimRetentionPolicy
                *out = new(StatefulSetPersistentVolumeClaimRetentionPolicy)
                **out = **in
        }
        if in.Ordinals != nil {
                in, out := &in.Ordinals, &out.Ordinals
                *out = new(StatefulSetOrdinals)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetSpec.
func (in *StatefulSetSpec) DeepCopy() *StatefulSetSpec {
        if in == nil {
                return nil
        }
        out := new(StatefulSetSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StatefulSetStatus) DeepCopyInto(out *StatefulSetStatus) {
        *out = *in
        if in.ObservedGeneration != nil {
                in, out := &in.ObservedGeneration, &out.ObservedGeneration
                *out = new(int64)
                **out = **in
        }
        if in.CollisionCount != nil {
                in, out := &in.CollisionCount, &out.CollisionCount
                *out = new(int32)
                **out = **in
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]StatefulSetCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetStatus.
func (in *StatefulSetStatus) DeepCopy() *StatefulSetStatus {
        if in == nil {
                return nil
        }
        out := new(StatefulSetStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StatefulSetUpdateStrategy) DeepCopyInto(out *StatefulSetUpdateStrategy) {
        *out = *in
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(RollingUpdateStatefulSetStrategy)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StatefulSetUpdateStrategy.
func (in *StatefulSetUpdateStrategy) DeepCopy() *StatefulSetUpdateStrategy {
        if in == nil {
                return nil
        }
        out := new(StatefulSetUpdateStrategy)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

// Package install installs the experimental API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/authentication"
        "k8s.io/kubernetes/pkg/apis/authentication/v1"
        "k8s.io/kubernetes/pkg/apis/authentication/v1alpha1"
        "k8s.io/kubernetes/pkg/apis/authentication/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(authentication.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1alpha1.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion, v1alpha1.SchemeGroupVersion))
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package authentication

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "authentication.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder points to a list of functions added to Scheme.
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme applies all the stored functions to the scheme.
        AddToScheme = SchemeBuilder.AddToScheme
)

func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &TokenReview{},
                &TokenRequest{},
                &SelfSubjectReview{},
        )
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        v1 "k8s.io/api/authentication/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        authentication "k8s.io/kubernetes/pkg/apis/authentication"
)

// Convert_v1_UserInfo_To_authentication_UserInfo is defined outside the autogenerated file for use by other API packages
// This is needed because it is referenced from other APIs, but is invisible at code-generation time because of the build tags.
func Convert_v1_UserInfo_To_authentication_UserInfo(in *v1.UserInfo, out *authentication.UserInfo, s conversion.Scope) error {
        return autoConvert_v1_UserInfo_To_authentication_UserInfo(in, out, s)
}

// Convert_authentication_UserInfo_To_v1_UserInfo is defined outside the autogenerated file for use by other API packages
// This is needed because it is referenced from other APIs, but is invisible at code-generation time because of the build tags.
func Convert_authentication_UserInfo_To_v1_UserInfo(in *authentication.UserInfo, out *v1.UserInfo, s conversion.Scope) error {
        return autoConvert_authentication_UserInfo_To_v1_UserInfo(in, out, s)
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        authenticationv1 "k8s.io/api/authentication/v1"
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_TokenRequestSpec(obj *authenticationv1.TokenRequestSpec) {
        if obj.ExpirationSeconds == nil {
                hour := int64(60 * 60)
                obj.ExpirationSeconds = &hour
        }
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        authenticationv1 "k8s.io/api/authentication/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "authentication.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &authenticationv1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        authenticationv1 "k8s.io/api/authentication/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        types "k8s.io/apimachinery/pkg/types"
        authentication "k8s.io/kubernetes/pkg/apis/authentication"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*authenticationv1.BoundObjectReference)(nil), (*authentication.BoundObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_BoundObjectReference_To_authentication_BoundObjectReference(a.(*authenticationv1.BoundObjectReference), b.(*authentication.BoundObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.BoundObjectReference)(nil), (*authenticationv1.BoundObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_BoundObjectReference_To_v1_BoundObjectReference(a.(*authentication.BoundObjectReference), b.(*authenticationv1.BoundObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1.SelfSubjectReview)(nil), (*authentication.SelfSubjectReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SelfSubjectReview_To_authentication_SelfSubjectReview(a.(*authenticationv1.SelfSubjectReview), b.(*authentication.SelfSubjectReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.SelfSubjectReview)(nil), (*authenticationv1.SelfSubjectReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_SelfSubjectReview_To_v1_SelfSubjectReview(a.(*authentication.SelfSubjectReview), b.(*authenticationv1.SelfSubjectReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1.SelfSubjectReviewStatus)(nil), (*authentication.SelfSubjectReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(a.(*authenticationv1.SelfSubjectReviewStatus), b.(*authentication.SelfSubjectReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.SelfSubjectReviewStatus)(nil), (*authenticationv1.SelfSubjectReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_SelfSubjectReviewStatus_To_v1_SelfSubjectReviewStatus(a.(*authentication.SelfSubjectReviewStatus), b.(*authenticationv1.SelfSubjectReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1.TokenRequest)(nil), (*authentication.TokenRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TokenRequest_To_authentication_TokenRequest(a.(*authenticationv1.TokenRequest), b.(*authentication.TokenRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenRequest)(nil), (*authenticationv1.TokenRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenRequest_To_v1_TokenRequest(a.(*authentication.TokenRequest), b.(*authenticationv1.TokenRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1.TokenRequestSpec)(nil), (*authentication.TokenRequestSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TokenRequestSpec_To_authentication_TokenRequestSpec(a.(*authenticationv1.TokenRequestSpec), b.(*authentication.TokenRequestSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenRequestSpec)(nil), (*authenticationv1.TokenRequestSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenRequestSpec_To_v1_TokenRequestSpec(a.(*authentication.TokenRequestSpec), b.(*authenticationv1.TokenRequestSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1.TokenRequestStatus)(nil), (*authentication.TokenRequestStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TokenRequestStatus_To_authentication_TokenRequestStatus(a.(*authenticationv1.TokenRequestStatus), b.(*authentication.TokenRequestStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenRequestStatus)(nil), (*authenticationv1.TokenRequestStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenRequestStatus_To_v1_TokenRequestStatus(a.(*authentication.TokenRequestStatus), b.(*authenticationv1.TokenRequestStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1.TokenReview)(nil), (*authentication.TokenReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TokenReview_To_authentication_TokenReview(a.(*authenticationv1.TokenReview), b.(*authentication.TokenReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenReview)(nil), (*authenticationv1.TokenReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenReview_To_v1_TokenReview(a.(*authentication.TokenReview), b.(*authenticationv1.TokenReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1.TokenReviewSpec)(nil), (*authentication.TokenReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TokenReviewSpec_To_authentication_TokenReviewSpec(a.(*authenticationv1.TokenReviewSpec), b.(*authentication.TokenReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenReviewSpec)(nil), (*authenticationv1.TokenReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenReviewSpec_To_v1_TokenReviewSpec(a.(*authentication.TokenReviewSpec), b.(*authenticationv1.TokenReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1.TokenReviewStatus)(nil), (*authentication.TokenReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TokenReviewStatus_To_authentication_TokenReviewStatus(a.(*authenticationv1.TokenReviewStatus), b.(*authentication.TokenReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenReviewStatus)(nil), (*authenticationv1.TokenReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenReviewStatus_To_v1_TokenReviewStatus(a.(*authentication.TokenReviewStatus), b.(*authenticationv1.TokenReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*authentication.UserInfo)(nil), (*authenticationv1.UserInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_UserInfo_To_v1_UserInfo(a.(*authentication.UserInfo), b.(*authenticationv1.UserInfo), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*authenticationv1.UserInfo)(nil), (*authentication.UserInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_UserInfo_To_authentication_UserInfo(a.(*authenticationv1.UserInfo), b.(*authentication.UserInfo), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_BoundObjectReference_To_authentication_BoundObjectReference(in *authenticationv1.BoundObjectReference, out *authentication.BoundObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.APIVersion = in.APIVersion
        out.Name = in.Name
        out.UID = types.UID(in.UID)
        return nil
}

// Convert_v1_BoundObjectReference_To_authentication_BoundObjectReference is an autogenerated conversion function.
func Convert_v1_BoundObjectReference_To_authentication_BoundObjectReference(in *authenticationv1.BoundObjectReference, out *authentication.BoundObjectReference, s conversion.Scope) error {
        return autoConvert_v1_BoundObjectReference_To_authentication_BoundObjectReference(in, out, s)
}

func autoConvert_authentication_BoundObjectReference_To_v1_BoundObjectReference(in *authentication.BoundObjectReference, out *authenticationv1.BoundObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.APIVersion = in.APIVersion
        out.Name = in.Name
        out.UID = types.UID(in.UID)
        return nil
}

// Convert_authentication_BoundObjectReference_To_v1_BoundObjectReference is an autogenerated conversion function.
func Convert_authentication_BoundObjectReference_To_v1_BoundObjectReference(in *authentication.BoundObjectReference, out *authenticationv1.BoundObjectReference, s conversion.Scope) error {
        return autoConvert_authentication_BoundObjectReference_To_v1_BoundObjectReference(in, out, s)
}

func autoConvert_v1_SelfSubjectReview_To_authentication_SelfSubjectReview(in *authenticationv1.SelfSubjectReview, out *authentication.SelfSubjectReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_SelfSubjectReview_To_authentication_SelfSubjectReview is an autogenerated conversion function.
func Convert_v1_SelfSubjectReview_To_authentication_SelfSubjectReview(in *authenticationv1.SelfSubjectReview, out *authentication.SelfSubjectReview, s conversion.Scope) error {
        return autoConvert_v1_SelfSubjectReview_To_authentication_SelfSubjectReview(in, out, s)
}

func autoConvert_authentication_SelfSubjectReview_To_v1_SelfSubjectReview(in *authentication.SelfSubjectReview, out *authenticationv1.SelfSubjectReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authentication_SelfSubjectReviewStatus_To_v1_SelfSubjectReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_SelfSubjectReview_To_v1_SelfSubjectReview is an autogenerated conversion function.
func Convert_authentication_SelfSubjectReview_To_v1_SelfSubjectReview(in *authentication.SelfSubjectReview, out *authenticationv1.SelfSubjectReview, s conversion.Scope) error {
        return autoConvert_authentication_SelfSubjectReview_To_v1_SelfSubjectReview(in, out, s)
}

func autoConvert_v1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in *authenticationv1.SelfSubjectReviewStatus, out *authentication.SelfSubjectReviewStatus, s conversion.Scope) error {
        if err := Convert_v1_UserInfo_To_authentication_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus is an autogenerated conversion function.
func Convert_v1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in *authenticationv1.SelfSubjectReviewStatus, out *authentication.SelfSubjectReviewStatus, s conversion.Scope) error {
        return autoConvert_v1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in, out, s)
}

func autoConvert_authentication_SelfSubjectReviewStatus_To_v1_SelfSubjectReviewStatus(in *authentication.SelfSubjectReviewStatus, out *authenticationv1.SelfSubjectReviewStatus, s conversion.Scope) error {
        if err := Convert_authentication_UserInfo_To_v1_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_SelfSubjectReviewStatus_To_v1_SelfSubjectReviewStatus is an autogenerated conversion function.
func Convert_authentication_SelfSubjectReviewStatus_To_v1_SelfSubjectReviewStatus(in *authentication.SelfSubjectReviewStatus, out *authenticationv1.SelfSubjectReviewStatus, s conversion.Scope) error {
        return autoConvert_authentication_SelfSubjectReviewStatus_To_v1_SelfSubjectReviewStatus(in, out, s)
}

func autoConvert_v1_TokenRequest_To_authentication_TokenRequest(in *authenticationv1.TokenRequest, out *authentication.TokenRequest, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_TokenRequestSpec_To_authentication_TokenRequestSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_TokenRequestStatus_To_authentication_TokenRequestStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_TokenRequest_To_authentication_TokenRequest is an autogenerated conversion function.
func Convert_v1_TokenRequest_To_authentication_TokenRequest(in *authenticationv1.TokenRequest, out *authentication.TokenRequest, s conversion.Scope) error {
        return autoConvert_v1_TokenRequest_To_authentication_TokenRequest(in, out, s)
}

func autoConvert_authentication_TokenRequest_To_v1_TokenRequest(in *authentication.TokenRequest, out *authenticationv1.TokenRequest, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authentication_TokenRequestSpec_To_v1_TokenRequestSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authentication_TokenRequestStatus_To_v1_TokenRequestStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_TokenRequest_To_v1_TokenRequest is an autogenerated conversion function.
func Convert_authentication_TokenRequest_To_v1_TokenRequest(in *authentication.TokenRequest, out *authenticationv1.TokenRequest, s conversion.Scope) error {
        return autoConvert_authentication_TokenRequest_To_v1_TokenRequest(in, out, s)
}

func autoConvert_v1_TokenRequestSpec_To_authentication_TokenRequestSpec(in *authenticationv1.TokenRequestSpec, out *authentication.TokenRequestSpec, s conversion.Scope) error {
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        if err := metav1.Convert_Pointer_int64_To_int64(&in.ExpirationSeconds, &out.ExpirationSeconds, s); err != nil {
                return err
        }
        out.BoundObjectRef = (*authentication.BoundObjectReference)(unsafe.Pointer(in.BoundObjectRef))
        return nil
}

// Convert_v1_TokenRequestSpec_To_authentication_TokenRequestSpec is an autogenerated conversion function.
func Convert_v1_TokenRequestSpec_To_authentication_TokenRequestSpec(in *authenticationv1.TokenRequestSpec, out *authentication.TokenRequestSpec, s conversion.Scope) error {
        return autoConvert_v1_TokenRequestSpec_To_authentication_TokenRequestSpec(in, out, s)
}

func autoConvert_authentication_TokenRequestSpec_To_v1_TokenRequestSpec(in *authentication.TokenRequestSpec, out *authenticationv1.TokenRequestSpec, s conversion.Scope) error {
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        if err := metav1.Convert_int64_To_Pointer_int64(&in.ExpirationSeconds, &out.ExpirationSeconds, s); err != nil {
                return err
        }
        out.BoundObjectRef = (*authenticationv1.BoundObjectReference)(unsafe.Pointer(in.BoundObjectRef))
        return nil
}

// Convert_authentication_TokenRequestSpec_To_v1_TokenRequestSpec is an autogenerated conversion function.
func Convert_authentication_TokenRequestSpec_To_v1_TokenRequestSpec(in *authentication.TokenRequestSpec, out *authenticationv1.TokenRequestSpec, s conversion.Scope) error {
        return autoConvert_authentication_TokenRequestSpec_To_v1_TokenRequestSpec(in, out, s)
}

func autoConvert_v1_TokenRequestStatus_To_authentication_TokenRequestStatus(in *authenticationv1.TokenRequestStatus, out *authentication.TokenRequestStatus, s conversion.Scope) error {
        out.Token = in.Token
        out.ExpirationTimestamp = in.ExpirationTimestamp
        return nil
}

// Convert_v1_TokenRequestStatus_To_authentication_TokenRequestStatus is an autogenerated conversion function.
func Convert_v1_TokenRequestStatus_To_authentication_TokenRequestStatus(in *authenticationv1.TokenRequestStatus, out *authentication.TokenRequestStatus, s conversion.Scope) error {
        return autoConvert_v1_TokenRequestStatus_To_authentication_TokenRequestStatus(in, out, s)
}

func autoConvert_authentication_TokenRequestStatus_To_v1_TokenRequestStatus(in *authentication.TokenRequestStatus, out *authenticationv1.TokenRequestStatus, s conversion.Scope) error {
        out.Token = in.Token
        out.ExpirationTimestamp = in.ExpirationTimestamp
        return nil
}

// Convert_authentication_TokenRequestStatus_To_v1_TokenRequestStatus is an autogenerated conversion function.
func Convert_authentication_TokenRequestStatus_To_v1_TokenRequestStatus(in *authentication.TokenRequestStatus, out *authenticationv1.TokenRequestStatus, s conversion.Scope) error {
        return autoConvert_authentication_TokenRequestStatus_To_v1_TokenRequestStatus(in, out, s)
}

func autoConvert_v1_TokenReview_To_authentication_TokenReview(in *authenticationv1.TokenReview, out *authentication.TokenReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_TokenReviewSpec_To_authentication_TokenReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_TokenReviewStatus_To_authentication_TokenReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_TokenReview_To_authentication_TokenReview is an autogenerated conversion function.
func Convert_v1_TokenReview_To_authentication_TokenReview(in *authenticationv1.TokenReview, out *authentication.TokenReview, s conversion.Scope) error {
        return autoConvert_v1_TokenReview_To_authentication_TokenReview(in, out, s)
}

func autoConvert_authentication_TokenReview_To_v1_TokenReview(in *authentication.TokenReview, out *authenticationv1.TokenReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authentication_TokenReviewSpec_To_v1_TokenReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authentication_TokenReviewStatus_To_v1_TokenReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_TokenReview_To_v1_TokenReview is an autogenerated conversion function.
func Convert_authentication_TokenReview_To_v1_TokenReview(in *authentication.TokenReview, out *authenticationv1.TokenReview, s conversion.Scope) error {
        return autoConvert_authentication_TokenReview_To_v1_TokenReview(in, out, s)
}

func autoConvert_v1_TokenReviewSpec_To_authentication_TokenReviewSpec(in *authenticationv1.TokenReviewSpec, out *authentication.TokenReviewSpec, s conversion.Scope) error {
        out.Token = in.Token
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        return nil
}

// Convert_v1_TokenReviewSpec_To_authentication_TokenReviewSpec is an autogenerated conversion function.
func Convert_v1_TokenReviewSpec_To_authentication_TokenReviewSpec(in *authenticationv1.TokenReviewSpec, out *authentication.TokenReviewSpec, s conversion.Scope) error {
        return autoConvert_v1_TokenReviewSpec_To_authentication_TokenReviewSpec(in, out, s)
}

func autoConvert_authentication_TokenReviewSpec_To_v1_TokenReviewSpec(in *authentication.TokenReviewSpec, out *authenticationv1.TokenReviewSpec, s conversion.Scope) error {
        out.Token = in.Token
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        return nil
}

// Convert_authentication_TokenReviewSpec_To_v1_TokenReviewSpec is an autogenerated conversion function.
func Convert_authentication_TokenReviewSpec_To_v1_TokenReviewSpec(in *authentication.TokenReviewSpec, out *authenticationv1.TokenReviewSpec, s conversion.Scope) error {
        return autoConvert_authentication_TokenReviewSpec_To_v1_TokenReviewSpec(in, out, s)
}

func autoConvert_v1_TokenReviewStatus_To_authentication_TokenReviewStatus(in *authenticationv1.TokenReviewStatus, out *authentication.TokenReviewStatus, s conversion.Scope) error {
        out.Authenticated = in.Authenticated
        if err := Convert_v1_UserInfo_To_authentication_UserInfo(&in.User, &out.User, s); err != nil {
                return err
        }
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        out.Error = in.Error
        return nil
}

// Convert_v1_TokenReviewStatus_To_authentication_TokenReviewStatus is an autogenerated conversion function.
func Convert_v1_TokenReviewStatus_To_authentication_TokenReviewStatus(in *authenticationv1.TokenReviewStatus, out *authentication.TokenReviewStatus, s conversion.Scope) error {
        return autoConvert_v1_TokenReviewStatus_To_authentication_TokenReviewStatus(in, out, s)
}

func autoConvert_authentication_TokenReviewStatus_To_v1_TokenReviewStatus(in *authentication.TokenReviewStatus, out *authenticationv1.TokenReviewStatus, s conversion.Scope) error {
        out.Authenticated = in.Authenticated
        if err := Convert_authentication_UserInfo_To_v1_UserInfo(&in.User, &out.User, s); err != nil {
                return err
        }
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        out.Error = in.Error
        return nil
}

// Convert_authentication_TokenReviewStatus_To_v1_TokenReviewStatus is an autogenerated conversion function.
func Convert_authentication_TokenReviewStatus_To_v1_TokenReviewStatus(in *authentication.TokenReviewStatus, out *authenticationv1.TokenReviewStatus, s conversion.Scope) error {
        return autoConvert_authentication_TokenReviewStatus_To_v1_TokenReviewStatus(in, out, s)
}

func autoConvert_v1_UserInfo_To_authentication_UserInfo(in *authenticationv1.UserInfo, out *authentication.UserInfo, s conversion.Scope) error {
        out.Username = in.Username
        out.UID = in.UID
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]authentication.ExtraValue)(unsafe.Pointer(&in.Extra))
        return nil
}

func autoConvert_authentication_UserInfo_To_v1_UserInfo(in *authentication.UserInfo, out *authenticationv1.UserInfo, s conversion.Scope) error {
        out.Username = in.Username
        out.UID = in.UID
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]authenticationv1.ExtraValue)(unsafe.Pointer(&in.Extra))
        return nil
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        authenticationv1 "k8s.io/api/authentication/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&authenticationv1.TokenRequest{}, func(obj interface{}) { SetObjectDefaults_TokenRequest(obj.(*authenticationv1.TokenRequest)) })
        return nil
}

func SetObjectDefaults_TokenRequest(in *authenticationv1.TokenRequest) {
        SetDefaults_TokenRequestSpec(&in.Spec)
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package v1alpha1

import (
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package v1alpha1

import (
        authenticationv1alpha1 "k8s.io/api/authentication/v1alpha1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "authentication.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &authenticationv1alpha1.SchemeBuilder
        // AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1alpha1

import (
        authenticationv1alpha1 "k8s.io/api/authentication/v1alpha1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        authentication "k8s.io/kubernetes/pkg/apis/authentication"
        v1 "k8s.io/kubernetes/pkg/apis/authentication/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*authenticationv1alpha1.SelfSubjectReview)(nil), (*authentication.SelfSubjectReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_SelfSubjectReview_To_authentication_SelfSubjectReview(a.(*authenticationv1alpha1.SelfSubjectReview), b.(*authentication.SelfSubjectReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.SelfSubjectReview)(nil), (*authenticationv1alpha1.SelfSubjectReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_SelfSubjectReview_To_v1alpha1_SelfSubjectReview(a.(*authentication.SelfSubjectReview), b.(*authenticationv1alpha1.SelfSubjectReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1alpha1.SelfSubjectReviewStatus)(nil), (*authentication.SelfSubjectReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(a.(*authenticationv1alpha1.SelfSubjectReviewStatus), b.(*authentication.SelfSubjectReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.SelfSubjectReviewStatus)(nil), (*authenticationv1alpha1.SelfSubjectReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_SelfSubjectReviewStatus_To_v1alpha1_SelfSubjectReviewStatus(a.(*authentication.SelfSubjectReviewStatus), b.(*authenticationv1alpha1.SelfSubjectReviewStatus), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1alpha1_SelfSubjectReview_To_authentication_SelfSubjectReview(in *authenticationv1alpha1.SelfSubjectReview, out *authentication.SelfSubjectReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1alpha1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_SelfSubjectReview_To_authentication_SelfSubjectReview is an autogenerated conversion function.
func Convert_v1alpha1_SelfSubjectReview_To_authentication_SelfSubjectReview(in *authenticationv1alpha1.SelfSubjectReview, out *authentication.SelfSubjectReview, s conversion.Scope) error {
        return autoConvert_v1alpha1_SelfSubjectReview_To_authentication_SelfSubjectReview(in, out, s)
}

func autoConvert_authentication_SelfSubjectReview_To_v1alpha1_SelfSubjectReview(in *authentication.SelfSubjectReview, out *authenticationv1alpha1.SelfSubjectReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authentication_SelfSubjectReviewStatus_To_v1alpha1_SelfSubjectReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_SelfSubjectReview_To_v1alpha1_SelfSubjectReview is an autogenerated conversion function.
func Convert_authentication_SelfSubjectReview_To_v1alpha1_SelfSubjectReview(in *authentication.SelfSubjectReview, out *authenticationv1alpha1.SelfSubjectReview, s conversion.Scope) error {
        return autoConvert_authentication_SelfSubjectReview_To_v1alpha1_SelfSubjectReview(in, out, s)
}

func autoConvert_v1alpha1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in *authenticationv1alpha1.SelfSubjectReviewStatus, out *authentication.SelfSubjectReviewStatus, s conversion.Scope) error {
        if err := v1.Convert_v1_UserInfo_To_authentication_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus is an autogenerated conversion function.
func Convert_v1alpha1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in *authenticationv1alpha1.SelfSubjectReviewStatus, out *authentication.SelfSubjectReviewStatus, s conversion.Scope) error {
        return autoConvert_v1alpha1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in, out, s)
}

func autoConvert_authentication_SelfSubjectReviewStatus_To_v1alpha1_SelfSubjectReviewStatus(in *authentication.SelfSubjectReviewStatus, out *authenticationv1alpha1.SelfSubjectReviewStatus, s conversion.Scope) error {
        if err := v1.Convert_authentication_UserInfo_To_v1_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_SelfSubjectReviewStatus_To_v1alpha1_SelfSubjectReviewStatus is an autogenerated conversion function.
func Convert_authentication_SelfSubjectReviewStatus_To_v1alpha1_SelfSubjectReviewStatus(in *authentication.SelfSubjectReviewStatus, out *authenticationv1alpha1.SelfSubjectReviewStatus, s conversion.Scope) error {
        return autoConvert_authentication_SelfSubjectReviewStatus_To_v1alpha1_SelfSubjectReviewStatus(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1alpha1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        authenticationv1beta1 "k8s.io/api/authentication/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "authentication.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &authenticationv1beta1.SchemeBuilder
        // AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        authenticationv1beta1 "k8s.io/api/authentication/v1beta1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        authentication "k8s.io/kubernetes/pkg/apis/authentication"
        v1 "k8s.io/kubernetes/pkg/apis/authentication/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*authenticationv1beta1.SelfSubjectReview)(nil), (*authentication.SelfSubjectReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SelfSubjectReview_To_authentication_SelfSubjectReview(a.(*authenticationv1beta1.SelfSubjectReview), b.(*authentication.SelfSubjectReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.SelfSubjectReview)(nil), (*authenticationv1beta1.SelfSubjectReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_SelfSubjectReview_To_v1beta1_SelfSubjectReview(a.(*authentication.SelfSubjectReview), b.(*authenticationv1beta1.SelfSubjectReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1beta1.SelfSubjectReviewStatus)(nil), (*authentication.SelfSubjectReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(a.(*authenticationv1beta1.SelfSubjectReviewStatus), b.(*authentication.SelfSubjectReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.SelfSubjectReviewStatus)(nil), (*authenticationv1beta1.SelfSubjectReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_SelfSubjectReviewStatus_To_v1beta1_SelfSubjectReviewStatus(a.(*authentication.SelfSubjectReviewStatus), b.(*authenticationv1beta1.SelfSubjectReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1beta1.TokenReview)(nil), (*authentication.TokenReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_TokenReview_To_authentication_TokenReview(a.(*authenticationv1beta1.TokenReview), b.(*authentication.TokenReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenReview)(nil), (*authenticationv1beta1.TokenReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenReview_To_v1beta1_TokenReview(a.(*authentication.TokenReview), b.(*authenticationv1beta1.TokenReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1beta1.TokenReviewSpec)(nil), (*authentication.TokenReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_TokenReviewSpec_To_authentication_TokenReviewSpec(a.(*authenticationv1beta1.TokenReviewSpec), b.(*authentication.TokenReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenReviewSpec)(nil), (*authenticationv1beta1.TokenReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenReviewSpec_To_v1beta1_TokenReviewSpec(a.(*authentication.TokenReviewSpec), b.(*authenticationv1beta1.TokenReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1beta1.TokenReviewStatus)(nil), (*authentication.TokenReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_TokenReviewStatus_To_authentication_TokenReviewStatus(a.(*authenticationv1beta1.TokenReviewStatus), b.(*authentication.TokenReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.TokenReviewStatus)(nil), (*authenticationv1beta1.TokenReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_TokenReviewStatus_To_v1beta1_TokenReviewStatus(a.(*authentication.TokenReviewStatus), b.(*authenticationv1beta1.TokenReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authenticationv1beta1.UserInfo)(nil), (*authentication.UserInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_UserInfo_To_authentication_UserInfo(a.(*authenticationv1beta1.UserInfo), b.(*authentication.UserInfo), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authentication.UserInfo)(nil), (*authenticationv1beta1.UserInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authentication_UserInfo_To_v1beta1_UserInfo(a.(*authentication.UserInfo), b.(*authenticationv1beta1.UserInfo), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_SelfSubjectReview_To_authentication_SelfSubjectReview(in *authenticationv1beta1.SelfSubjectReview, out *authentication.SelfSubjectReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_SelfSubjectReview_To_authentication_SelfSubjectReview is an autogenerated conversion function.
func Convert_v1beta1_SelfSubjectReview_To_authentication_SelfSubjectReview(in *authenticationv1beta1.SelfSubjectReview, out *authentication.SelfSubjectReview, s conversion.Scope) error {
        return autoConvert_v1beta1_SelfSubjectReview_To_authentication_SelfSubjectReview(in, out, s)
}

func autoConvert_authentication_SelfSubjectReview_To_v1beta1_SelfSubjectReview(in *authentication.SelfSubjectReview, out *authenticationv1beta1.SelfSubjectReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authentication_SelfSubjectReviewStatus_To_v1beta1_SelfSubjectReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_SelfSubjectReview_To_v1beta1_SelfSubjectReview is an autogenerated conversion function.
func Convert_authentication_SelfSubjectReview_To_v1beta1_SelfSubjectReview(in *authentication.SelfSubjectReview, out *authenticationv1beta1.SelfSubjectReview, s conversion.Scope) error {
        return autoConvert_authentication_SelfSubjectReview_To_v1beta1_SelfSubjectReview(in, out, s)
}

func autoConvert_v1beta1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in *authenticationv1beta1.SelfSubjectReviewStatus, out *authentication.SelfSubjectReviewStatus, s conversion.Scope) error {
        if err := v1.Convert_v1_UserInfo_To_authentication_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus is an autogenerated conversion function.
func Convert_v1beta1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in *authenticationv1beta1.SelfSubjectReviewStatus, out *authentication.SelfSubjectReviewStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_SelfSubjectReviewStatus_To_authentication_SelfSubjectReviewStatus(in, out, s)
}

func autoConvert_authentication_SelfSubjectReviewStatus_To_v1beta1_SelfSubjectReviewStatus(in *authentication.SelfSubjectReviewStatus, out *authenticationv1beta1.SelfSubjectReviewStatus, s conversion.Scope) error {
        if err := v1.Convert_authentication_UserInfo_To_v1_UserInfo(&in.UserInfo, &out.UserInfo, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_SelfSubjectReviewStatus_To_v1beta1_SelfSubjectReviewStatus is an autogenerated conversion function.
func Convert_authentication_SelfSubjectReviewStatus_To_v1beta1_SelfSubjectReviewStatus(in *authentication.SelfSubjectReviewStatus, out *authenticationv1beta1.SelfSubjectReviewStatus, s conversion.Scope) error {
        return autoConvert_authentication_SelfSubjectReviewStatus_To_v1beta1_SelfSubjectReviewStatus(in, out, s)
}

func autoConvert_v1beta1_TokenReview_To_authentication_TokenReview(in *authenticationv1beta1.TokenReview, out *authentication.TokenReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_TokenReviewSpec_To_authentication_TokenReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_TokenReviewStatus_To_authentication_TokenReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_TokenReview_To_authentication_TokenReview is an autogenerated conversion function.
func Convert_v1beta1_TokenReview_To_authentication_TokenReview(in *authenticationv1beta1.TokenReview, out *authentication.TokenReview, s conversion.Scope) error {
        return autoConvert_v1beta1_TokenReview_To_authentication_TokenReview(in, out, s)
}

func autoConvert_authentication_TokenReview_To_v1beta1_TokenReview(in *authentication.TokenReview, out *authenticationv1beta1.TokenReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authentication_TokenReviewSpec_To_v1beta1_TokenReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authentication_TokenReviewStatus_To_v1beta1_TokenReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authentication_TokenReview_To_v1beta1_TokenReview is an autogenerated conversion function.
func Convert_authentication_TokenReview_To_v1beta1_TokenReview(in *authentication.TokenReview, out *authenticationv1beta1.TokenReview, s conversion.Scope) error {
        return autoConvert_authentication_TokenReview_To_v1beta1_TokenReview(in, out, s)
}

func autoConvert_v1beta1_TokenReviewSpec_To_authentication_TokenReviewSpec(in *authenticationv1beta1.TokenReviewSpec, out *authentication.TokenReviewSpec, s conversion.Scope) error {
        out.Token = in.Token
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        return nil
}

// Convert_v1beta1_TokenReviewSpec_To_authentication_TokenReviewSpec is an autogenerated conversion function.
func Convert_v1beta1_TokenReviewSpec_To_authentication_TokenReviewSpec(in *authenticationv1beta1.TokenReviewSpec, out *authentication.TokenReviewSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_TokenReviewSpec_To_authentication_TokenReviewSpec(in, out, s)
}

func autoConvert_authentication_TokenReviewSpec_To_v1beta1_TokenReviewSpec(in *authentication.TokenReviewSpec, out *authenticationv1beta1.TokenReviewSpec, s conversion.Scope) error {
        out.Token = in.Token
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        return nil
}

// Convert_authentication_TokenReviewSpec_To_v1beta1_TokenReviewSpec is an autogenerated conversion function.
func Convert_authentication_TokenReviewSpec_To_v1beta1_TokenReviewSpec(in *authentication.TokenReviewSpec, out *authenticationv1beta1.TokenReviewSpec, s conversion.Scope) error {
        return autoConvert_authentication_TokenReviewSpec_To_v1beta1_TokenReviewSpec(in, out, s)
}

func autoConvert_v1beta1_TokenReviewStatus_To_authentication_TokenReviewStatus(in *authenticationv1beta1.TokenReviewStatus, out *authentication.TokenReviewStatus, s conversion.Scope) error {
        out.Authenticated = in.Authenticated
        if err := Convert_v1beta1_UserInfo_To_authentication_UserInfo(&in.User, &out.User, s); err != nil {
                return err
        }
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        out.Error = in.Error
        return nil
}

// Convert_v1beta1_TokenReviewStatus_To_authentication_TokenReviewStatus is an autogenerated conversion function.
func Convert_v1beta1_TokenReviewStatus_To_authentication_TokenReviewStatus(in *authenticationv1beta1.TokenReviewStatus, out *authentication.TokenReviewStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_TokenReviewStatus_To_authentication_TokenReviewStatus(in, out, s)
}

func autoConvert_authentication_TokenReviewStatus_To_v1beta1_TokenReviewStatus(in *authentication.TokenReviewStatus, out *authenticationv1beta1.TokenReviewStatus, s conversion.Scope) error {
        out.Authenticated = in.Authenticated
        if err := Convert_authentication_UserInfo_To_v1beta1_UserInfo(&in.User, &out.User, s); err != nil {
                return err
        }
        out.Audiences = *(*[]string)(unsafe.Pointer(&in.Audiences))
        out.Error = in.Error
        return nil
}

// Convert_authentication_TokenReviewStatus_To_v1beta1_TokenReviewStatus is an autogenerated conversion function.
func Convert_authentication_TokenReviewStatus_To_v1beta1_TokenReviewStatus(in *authentication.TokenReviewStatus, out *authenticationv1beta1.TokenReviewStatus, s conversion.Scope) error {
        return autoConvert_authentication_TokenReviewStatus_To_v1beta1_TokenReviewStatus(in, out, s)
}

func autoConvert_v1beta1_UserInfo_To_authentication_UserInfo(in *authenticationv1beta1.UserInfo, out *authentication.UserInfo, s conversion.Scope) error {
        out.Username = in.Username
        out.UID = in.UID
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]authentication.ExtraValue)(unsafe.Pointer(&in.Extra))
        return nil
}

// Convert_v1beta1_UserInfo_To_authentication_UserInfo is an autogenerated conversion function.
func Convert_v1beta1_UserInfo_To_authentication_UserInfo(in *authenticationv1beta1.UserInfo, out *authentication.UserInfo, s conversion.Scope) error {
        return autoConvert_v1beta1_UserInfo_To_authentication_UserInfo(in, out, s)
}

func autoConvert_authentication_UserInfo_To_v1beta1_UserInfo(in *authentication.UserInfo, out *authenticationv1beta1.UserInfo, s conversion.Scope) error {
        out.Username = in.Username
        out.UID = in.UID
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]authenticationv1beta1.ExtraValue)(unsafe.Pointer(&in.Extra))
        return nil
}

// Convert_authentication_UserInfo_To_v1beta1_UserInfo is an autogenerated conversion function.
func Convert_authentication_UserInfo_To_v1beta1_UserInfo(in *authentication.UserInfo, out *authenticationv1beta1.UserInfo, s conversion.Scope) error {
        return autoConvert_authentication_UserInfo_To_v1beta1_UserInfo(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package authentication

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *BoundObjectReference) DeepCopyInto(out *BoundObjectReference) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BoundObjectReference.
func (in *BoundObjectReference) DeepCopy() *BoundObjectReference {
        if in == nil {
                return nil
        }
        out := new(BoundObjectReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in ExtraValue) DeepCopyInto(out *ExtraValue) {
        {
                in := &in
                *out = make(ExtraValue, len(*in))
                copy(*out, *in)
                return
        }
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtraValue.
func (in ExtraValue) DeepCopy() ExtraValue {
        if in == nil {
                return nil
        }
        out := new(ExtraValue)
        in.DeepCopyInto(out)
        return *out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SelfSubjectReview) DeepCopyInto(out *SelfSubjectReview) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SelfSubjectReview.
func (in *SelfSubjectReview) DeepCopy() *SelfSubjectReview {
        if in == nil {
                return nil
        }
        out := new(SelfSubjectReview)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *SelfSubjectReview) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SelfSubjectReviewStatus) DeepCopyInto(out *SelfSubjectReviewStatus) {
        *out = *in
        in.UserInfo.DeepCopyInto(&out.UserInfo)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SelfSubjectReviewStatus.
func (in *SelfSubjectReviewStatus) DeepCopy() *SelfSubjectReviewStatus {
        if in == nil {
                return nil
        }
        out := new(SelfSubjectReviewStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TokenRequest) DeepCopyInto(out *TokenRequest) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TokenRequest.
func (in *TokenRequest) DeepCopy() *TokenRequest {
        if in == nil {
                return nil
        }
        out := new(TokenRequest)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *TokenRequest) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TokenRequestSpec) DeepCopyInto(out *TokenRequestSpec) {
        *out = *in
        if in.Audiences != nil {
                in, out := &in.Audiences, &out.Audiences
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.BoundObjectRef != nil {
                in, out := &in.BoundObjectRef, &out.BoundObjectRef
                *out = new(BoundObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TokenRequestSpec.
func (in *TokenRequestSpec) DeepCopy() *TokenRequestSpec {
        if in == nil {
                return nil
        }
        out := new(TokenRequestSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TokenRequestStatus) DeepCopyInto(out *TokenRequestStatus) {
        *out = *in
        in.ExpirationTimestamp.DeepCopyInto(&out.ExpirationTimestamp)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TokenRequestStatus.
func (in *TokenRequestStatus) DeepCopy() *TokenRequestStatus {
        if in == nil {
                return nil
        }
        out := new(TokenRequestStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TokenReview) DeepCopyInto(out *TokenReview) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TokenReview.
func (in *TokenReview) DeepCopy() *TokenReview {
        if in == nil {
                return nil
        }
        out := new(TokenReview)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *TokenReview) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TokenReviewSpec) DeepCopyInto(out *TokenReviewSpec) {
        *out = *in
        if in.Audiences != nil {
                in, out := &in.Audiences, &out.Audiences
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TokenReviewSpec.
func (in *TokenReviewSpec) DeepCopy() *TokenReviewSpec {
        if in == nil {
                return nil
        }
        out := new(TokenReviewSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TokenReviewStatus) DeepCopyInto(out *TokenReviewStatus) {
        *out = *in
        in.User.DeepCopyInto(&out.User)
        if in.Audiences != nil {
                in, out := &in.Audiences, &out.Audiences
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TokenReviewStatus.
func (in *TokenReviewStatus) DeepCopy() *TokenReviewStatus {
        if in == nil {
                return nil
        }
        out := new(TokenReviewStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *UserInfo) DeepCopyInto(out *UserInfo) {
        *out = *in
        if in.Groups != nil {
                in, out := &in.Groups, &out.Groups
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Extra != nil {
                in, out := &in.Extra, &out.Extra
                *out = make(map[string]ExtraValue, len(*in))
                for key, val := range *in {
                        var outVal []string
                        if val == nil {
                                (*out)[key] = nil
                        } else {
                                in, out := &val, &outVal
                                *out = make(ExtraValue, len(*in))
                                copy(*out, *in)
                        }
                        (*out)[key] = outVal
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserInfo.
func (in *UserInfo) DeepCopy() *UserInfo {
        if in == nil {
                return nil
        }
        out := new(UserInfo)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

// Package install installs the experimental API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/authorization"
        "k8s.io/kubernetes/pkg/apis/authorization/v1"
        "k8s.io/kubernetes/pkg/apis/authorization/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(authorization.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion))
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package authorization

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "authorization.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder points to a list of functions added to Scheme.
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme applies all the stored functions to the scheme.
        AddToScheme = SchemeBuilder.AddToScheme
)

func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &SelfSubjectRulesReview{},
                &SelfSubjectAccessReview{},
                &SubjectAccessReview{},
                &LocalSubjectAccessReview{},
        )
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        authorizationv1 "k8s.io/api/authorization/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "authorization.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // localSchemeBuilder extends the SchemeBuilder instance with the external types. In this package,
        // defaulting and conversion init funcs are registered as well.
        localSchemeBuilder = &authorizationv1.SchemeBuilder
        // AddToScheme is a global function that registers this API group & version to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        authorizationv1 "k8s.io/api/authorization/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        authorization "k8s.io/kubernetes/pkg/apis/authorization"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*authorizationv1.FieldSelectorAttributes)(nil), (*authorization.FieldSelectorAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FieldSelectorAttributes_To_authorization_FieldSelectorAttributes(a.(*authorizationv1.FieldSelectorAttributes), b.(*authorization.FieldSelectorAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.FieldSelectorAttributes)(nil), (*authorizationv1.FieldSelectorAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_FieldSelectorAttributes_To_v1_FieldSelectorAttributes(a.(*authorization.FieldSelectorAttributes), b.(*authorizationv1.FieldSelectorAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.LabelSelectorAttributes)(nil), (*authorization.LabelSelectorAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LabelSelectorAttributes_To_authorization_LabelSelectorAttributes(a.(*authorizationv1.LabelSelectorAttributes), b.(*authorization.LabelSelectorAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.LabelSelectorAttributes)(nil), (*authorizationv1.LabelSelectorAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_LabelSelectorAttributes_To_v1_LabelSelectorAttributes(a.(*authorization.LabelSelectorAttributes), b.(*authorizationv1.LabelSelectorAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.LocalSubjectAccessReview)(nil), (*authorization.LocalSubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(a.(*authorizationv1.LocalSubjectAccessReview), b.(*authorization.LocalSubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.LocalSubjectAccessReview)(nil), (*authorizationv1.LocalSubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_LocalSubjectAccessReview_To_v1_LocalSubjectAccessReview(a.(*authorization.LocalSubjectAccessReview), b.(*authorizationv1.LocalSubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.NonResourceAttributes)(nil), (*authorization.NonResourceAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NonResourceAttributes_To_authorization_NonResourceAttributes(a.(*authorizationv1.NonResourceAttributes), b.(*authorization.NonResourceAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.NonResourceAttributes)(nil), (*authorizationv1.NonResourceAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_NonResourceAttributes_To_v1_NonResourceAttributes(a.(*authorization.NonResourceAttributes), b.(*authorizationv1.NonResourceAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.NonResourceRule)(nil), (*authorization.NonResourceRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NonResourceRule_To_authorization_NonResourceRule(a.(*authorizationv1.NonResourceRule), b.(*authorization.NonResourceRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.NonResourceRule)(nil), (*authorizationv1.NonResourceRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_NonResourceRule_To_v1_NonResourceRule(a.(*authorization.NonResourceRule), b.(*authorizationv1.NonResourceRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.ResourceAttributes)(nil), (*authorization.ResourceAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceAttributes_To_authorization_ResourceAttributes(a.(*authorizationv1.ResourceAttributes), b.(*authorization.ResourceAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.ResourceAttributes)(nil), (*authorizationv1.ResourceAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_ResourceAttributes_To_v1_ResourceAttributes(a.(*authorization.ResourceAttributes), b.(*authorizationv1.ResourceAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.ResourceRule)(nil), (*authorization.ResourceRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceRule_To_authorization_ResourceRule(a.(*authorizationv1.ResourceRule), b.(*authorization.ResourceRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.ResourceRule)(nil), (*authorizationv1.ResourceRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_ResourceRule_To_v1_ResourceRule(a.(*authorization.ResourceRule), b.(*authorizationv1.ResourceRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.SelfSubjectAccessReview)(nil), (*authorization.SelfSubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(a.(*authorizationv1.SelfSubjectAccessReview), b.(*authorization.SelfSubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SelfSubjectAccessReview)(nil), (*authorizationv1.SelfSubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SelfSubjectAccessReview_To_v1_SelfSubjectAccessReview(a.(*authorization.SelfSubjectAccessReview), b.(*authorizationv1.SelfSubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.SelfSubjectAccessReviewSpec)(nil), (*authorization.SelfSubjectAccessReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(a.(*authorizationv1.SelfSubjectAccessReviewSpec), b.(*authorization.SelfSubjectAccessReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SelfSubjectAccessReviewSpec)(nil), (*authorizationv1.SelfSubjectAccessReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SelfSubjectAccessReviewSpec_To_v1_SelfSubjectAccessReviewSpec(a.(*authorization.SelfSubjectAccessReviewSpec), b.(*authorizationv1.SelfSubjectAccessReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.SelfSubjectRulesReview)(nil), (*authorization.SelfSubjectRulesReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview(a.(*authorizationv1.SelfSubjectRulesReview), b.(*authorization.SelfSubjectRulesReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SelfSubjectRulesReview)(nil), (*authorizationv1.SelfSubjectRulesReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SelfSubjectRulesReview_To_v1_SelfSubjectRulesReview(a.(*authorization.SelfSubjectRulesReview), b.(*authorizationv1.SelfSubjectRulesReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.SelfSubjectRulesReviewSpec)(nil), (*authorization.SelfSubjectRulesReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(a.(*authorizationv1.SelfSubjectRulesReviewSpec), b.(*authorization.SelfSubjectRulesReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SelfSubjectRulesReviewSpec)(nil), (*authorizationv1.SelfSubjectRulesReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SelfSubjectRulesReviewSpec_To_v1_SelfSubjectRulesReviewSpec(a.(*authorization.SelfSubjectRulesReviewSpec), b.(*authorizationv1.SelfSubjectRulesReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.SubjectAccessReview)(nil), (*authorization.SubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SubjectAccessReview_To_authorization_SubjectAccessReview(a.(*authorizationv1.SubjectAccessReview), b.(*authorization.SubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SubjectAccessReview)(nil), (*authorizationv1.SubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SubjectAccessReview_To_v1_SubjectAccessReview(a.(*authorization.SubjectAccessReview), b.(*authorizationv1.SubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.SubjectAccessReviewSpec)(nil), (*authorization.SubjectAccessReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(a.(*authorizationv1.SubjectAccessReviewSpec), b.(*authorization.SubjectAccessReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SubjectAccessReviewSpec)(nil), (*authorizationv1.SubjectAccessReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SubjectAccessReviewSpec_To_v1_SubjectAccessReviewSpec(a.(*authorization.SubjectAccessReviewSpec), b.(*authorizationv1.SubjectAccessReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.SubjectAccessReviewStatus)(nil), (*authorization.SubjectAccessReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(a.(*authorizationv1.SubjectAccessReviewStatus), b.(*authorization.SubjectAccessReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SubjectAccessReviewStatus)(nil), (*authorizationv1.SubjectAccessReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SubjectAccessReviewStatus_To_v1_SubjectAccessReviewStatus(a.(*authorization.SubjectAccessReviewStatus), b.(*authorizationv1.SubjectAccessReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1.SubjectRulesReviewStatus)(nil), (*authorization.SubjectRulesReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(a.(*authorizationv1.SubjectRulesReviewStatus), b.(*authorization.SubjectRulesReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SubjectRulesReviewStatus)(nil), (*authorizationv1.SubjectRulesReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SubjectRulesReviewStatus_To_v1_SubjectRulesReviewStatus(a.(*authorization.SubjectRulesReviewStatus), b.(*authorizationv1.SubjectRulesReviewStatus), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_FieldSelectorAttributes_To_authorization_FieldSelectorAttributes(in *authorizationv1.FieldSelectorAttributes, out *authorization.FieldSelectorAttributes, s conversion.Scope) error {
        out.RawSelector = in.RawSelector
        out.Requirements = *(*[]metav1.FieldSelectorRequirement)(unsafe.Pointer(&in.Requirements))
        return nil
}

// Convert_v1_FieldSelectorAttributes_To_authorization_FieldSelectorAttributes is an autogenerated conversion function.
func Convert_v1_FieldSelectorAttributes_To_authorization_FieldSelectorAttributes(in *authorizationv1.FieldSelectorAttributes, out *authorization.FieldSelectorAttributes, s conversion.Scope) error {
        return autoConvert_v1_FieldSelectorAttributes_To_authorization_FieldSelectorAttributes(in, out, s)
}

func autoConvert_authorization_FieldSelectorAttributes_To_v1_FieldSelectorAttributes(in *authorization.FieldSelectorAttributes, out *authorizationv1.FieldSelectorAttributes, s conversion.Scope) error {
        out.RawSelector = in.RawSelector
        out.Requirements = *(*[]metav1.FieldSelectorRequirement)(unsafe.Pointer(&in.Requirements))
        return nil
}

// Convert_authorization_FieldSelectorAttributes_To_v1_FieldSelectorAttributes is an autogenerated conversion function.
func Convert_authorization_FieldSelectorAttributes_To_v1_FieldSelectorAttributes(in *authorization.FieldSelectorAttributes, out *authorizationv1.FieldSelectorAttributes, s conversion.Scope) error {
        return autoConvert_authorization_FieldSelectorAttributes_To_v1_FieldSelectorAttributes(in, out, s)
}

func autoConvert_v1_LabelSelectorAttributes_To_authorization_LabelSelectorAttributes(in *authorizationv1.LabelSelectorAttributes, out *authorization.LabelSelectorAttributes, s conversion.Scope) error {
        out.RawSelector = in.RawSelector
        out.Requirements = *(*[]metav1.LabelSelectorRequirement)(unsafe.Pointer(&in.Requirements))
        return nil
}

// Convert_v1_LabelSelectorAttributes_To_authorization_LabelSelectorAttributes is an autogenerated conversion function.
func Convert_v1_LabelSelectorAttributes_To_authorization_LabelSelectorAttributes(in *authorizationv1.LabelSelectorAttributes, out *authorization.LabelSelectorAttributes, s conversion.Scope) error {
        return autoConvert_v1_LabelSelectorAttributes_To_authorization_LabelSelectorAttributes(in, out, s)
}

func autoConvert_authorization_LabelSelectorAttributes_To_v1_LabelSelectorAttributes(in *authorization.LabelSelectorAttributes, out *authorizationv1.LabelSelectorAttributes, s conversion.Scope) error {
        out.RawSelector = in.RawSelector
        out.Requirements = *(*[]metav1.LabelSelectorRequirement)(unsafe.Pointer(&in.Requirements))
        return nil
}

// Convert_authorization_LabelSelectorAttributes_To_v1_LabelSelectorAttributes is an autogenerated conversion function.
func Convert_authorization_LabelSelectorAttributes_To_v1_LabelSelectorAttributes(in *authorization.LabelSelectorAttributes, out *authorizationv1.LabelSelectorAttributes, s conversion.Scope) error {
        return autoConvert_authorization_LabelSelectorAttributes_To_v1_LabelSelectorAttributes(in, out, s)
}

func autoConvert_v1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in *authorizationv1.LocalSubjectAccessReview, out *authorization.LocalSubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview is an autogenerated conversion function.
func Convert_v1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in *authorizationv1.LocalSubjectAccessReview, out *authorization.LocalSubjectAccessReview, s conversion.Scope) error {
        return autoConvert_v1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in, out, s)
}

func autoConvert_authorization_LocalSubjectAccessReview_To_v1_LocalSubjectAccessReview(in *authorization.LocalSubjectAccessReview, out *authorizationv1.LocalSubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authorization_SubjectAccessReviewSpec_To_v1_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authorization_SubjectAccessReviewStatus_To_v1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authorization_LocalSubjectAccessReview_To_v1_LocalSubjectAccessReview is an autogenerated conversion function.
func Convert_authorization_LocalSubjectAccessReview_To_v1_LocalSubjectAccessReview(in *authorization.LocalSubjectAccessReview, out *authorizationv1.LocalSubjectAccessReview, s conversion.Scope) error {
        return autoConvert_authorization_LocalSubjectAccessReview_To_v1_LocalSubjectAccessReview(in, out, s)
}

func autoConvert_v1_NonResourceAttributes_To_authorization_NonResourceAttributes(in *authorizationv1.NonResourceAttributes, out *authorization.NonResourceAttributes, s conversion.Scope) error {
        out.Path = in.Path
        out.Verb = in.Verb
        return nil
}

// Convert_v1_NonResourceAttributes_To_authorization_NonResourceAttributes is an autogenerated conversion function.
func Convert_v1_NonResourceAttributes_To_authorization_NonResourceAttributes(in *authorizationv1.NonResourceAttributes, out *authorization.NonResourceAttributes, s conversion.Scope) error {
        return autoConvert_v1_NonResourceAttributes_To_authorization_NonResourceAttributes(in, out, s)
}

func autoConvert_authorization_NonResourceAttributes_To_v1_NonResourceAttributes(in *authorization.NonResourceAttributes, out *authorizationv1.NonResourceAttributes, s conversion.Scope) error {
        out.Path = in.Path
        out.Verb = in.Verb
        return nil
}

// Convert_authorization_NonResourceAttributes_To_v1_NonResourceAttributes is an autogenerated conversion function.
func Convert_authorization_NonResourceAttributes_To_v1_NonResourceAttributes(in *authorization.NonResourceAttributes, out *authorizationv1.NonResourceAttributes, s conversion.Scope) error {
        return autoConvert_authorization_NonResourceAttributes_To_v1_NonResourceAttributes(in, out, s)
}

func autoConvert_v1_NonResourceRule_To_authorization_NonResourceRule(in *authorizationv1.NonResourceRule, out *authorization.NonResourceRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs))
        return nil
}

// Convert_v1_NonResourceRule_To_authorization_NonResourceRule is an autogenerated conversion function.
func Convert_v1_NonResourceRule_To_authorization_NonResourceRule(in *authorizationv1.NonResourceRule, out *authorization.NonResourceRule, s conversion.Scope) error {
        return autoConvert_v1_NonResourceRule_To_authorization_NonResourceRule(in, out, s)
}

func autoConvert_authorization_NonResourceRule_To_v1_NonResourceRule(in *authorization.NonResourceRule, out *authorizationv1.NonResourceRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs))
        return nil
}

// Convert_authorization_NonResourceRule_To_v1_NonResourceRule is an autogenerated conversion function.
func Convert_authorization_NonResourceRule_To_v1_NonResourceRule(in *authorization.NonResourceRule, out *authorizationv1.NonResourceRule, s conversion.Scope) error {
        return autoConvert_authorization_NonResourceRule_To_v1_NonResourceRule(in, out, s)
}

func autoConvert_v1_ResourceAttributes_To_authorization_ResourceAttributes(in *authorizationv1.ResourceAttributes, out *authorization.ResourceAttributes, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Verb = in.Verb
        out.Group = in.Group
        out.Version = in.Version
        out.Resource = in.Resource
        out.Subresource = in.Subresource
        out.Name = in.Name
        out.FieldSelector = (*authorization.FieldSelectorAttributes)(unsafe.Pointer(in.FieldSelector))
        out.LabelSelector = (*authorization.LabelSelectorAttributes)(unsafe.Pointer(in.LabelSelector))
        return nil
}

// Convert_v1_ResourceAttributes_To_authorization_ResourceAttributes is an autogenerated conversion function.
func Convert_v1_ResourceAttributes_To_authorization_ResourceAttributes(in *authorizationv1.ResourceAttributes, out *authorization.ResourceAttributes, s conversion.Scope) error {
        return autoConvert_v1_ResourceAttributes_To_authorization_ResourceAttributes(in, out, s)
}

func autoConvert_authorization_ResourceAttributes_To_v1_ResourceAttributes(in *authorization.ResourceAttributes, out *authorizationv1.ResourceAttributes, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Verb = in.Verb
        out.Group = in.Group
        out.Version = in.Version
        out.Resource = in.Resource
        out.Subresource = in.Subresource
        out.Name = in.Name
        out.FieldSelector = (*authorizationv1.FieldSelectorAttributes)(unsafe.Pointer(in.FieldSelector))
        out.LabelSelector = (*authorizationv1.LabelSelectorAttributes)(unsafe.Pointer(in.LabelSelector))
        return nil
}

// Convert_authorization_ResourceAttributes_To_v1_ResourceAttributes is an autogenerated conversion function.
func Convert_authorization_ResourceAttributes_To_v1_ResourceAttributes(in *authorization.ResourceAttributes, out *authorizationv1.ResourceAttributes, s conversion.Scope) error {
        return autoConvert_authorization_ResourceAttributes_To_v1_ResourceAttributes(in, out, s)
}

func autoConvert_v1_ResourceRule_To_authorization_ResourceRule(in *authorizationv1.ResourceRule, out *authorization.ResourceRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.APIGroups = *(*[]string)(unsafe.Pointer(&in.APIGroups))
        out.Resources = *(*[]string)(unsafe.Pointer(&in.Resources))
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        return nil
}

// Convert_v1_ResourceRule_To_authorization_ResourceRule is an autogenerated conversion function.
func Convert_v1_ResourceRule_To_authorization_ResourceRule(in *authorizationv1.ResourceRule, out *authorization.ResourceRule, s conversion.Scope) error {
        return autoConvert_v1_ResourceRule_To_authorization_ResourceRule(in, out, s)
}

func autoConvert_authorization_ResourceRule_To_v1_ResourceRule(in *authorization.ResourceRule, out *authorizationv1.ResourceRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.APIGroups = *(*[]string)(unsafe.Pointer(&in.APIGroups))
        out.Resources = *(*[]string)(unsafe.Pointer(&in.Resources))
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        return nil
}

// Convert_authorization_ResourceRule_To_v1_ResourceRule is an autogenerated conversion function.
func Convert_authorization_ResourceRule_To_v1_ResourceRule(in *authorization.ResourceRule, out *authorizationv1.ResourceRule, s conversion.Scope) error {
        return autoConvert_authorization_ResourceRule_To_v1_ResourceRule(in, out, s)
}

func autoConvert_v1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in *authorizationv1.SelfSubjectAccessReview, out *authorization.SelfSubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview is an autogenerated conversion function.
func Convert_v1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in *authorizationv1.SelfSubjectAccessReview, out *authorization.SelfSubjectAccessReview, s conversion.Scope) error {
        return autoConvert_v1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in, out, s)
}

func autoConvert_authorization_SelfSubjectAccessReview_To_v1_SelfSubjectAccessReview(in *authorization.SelfSubjectAccessReview, out *authorizationv1.SelfSubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authorization_SelfSubjectAccessReviewSpec_To_v1_SelfSubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authorization_SubjectAccessReviewStatus_To_v1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authorization_SelfSubjectAccessReview_To_v1_SelfSubjectAccessReview is an autogenerated conversion function.
func Convert_authorization_SelfSubjectAccessReview_To_v1_SelfSubjectAccessReview(in *authorization.SelfSubjectAccessReview, out *authorizationv1.SelfSubjectAccessReview, s conversion.Scope) error {
        return autoConvert_authorization_SelfSubjectAccessReview_To_v1_SelfSubjectAccessReview(in, out, s)
}

func autoConvert_v1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in *authorizationv1.SelfSubjectAccessReviewSpec, out *authorization.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
        out.ResourceAttributes = (*authorization.ResourceAttributes)(unsafe.Pointer(in.ResourceAttributes))
        out.NonResourceAttributes = (*authorization.NonResourceAttributes)(unsafe.Pointer(in.NonResourceAttributes))
        return nil
}

// Convert_v1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec is an autogenerated conversion function.
func Convert_v1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in *authorizationv1.SelfSubjectAccessReviewSpec, out *authorization.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
        return autoConvert_v1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in, out, s)
}

func autoConvert_authorization_SelfSubjectAccessReviewSpec_To_v1_SelfSubjectAccessReviewSpec(in *authorization.SelfSubjectAccessReviewSpec, out *authorizationv1.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
        out.ResourceAttributes = (*authorizationv1.ResourceAttributes)(unsafe.Pointer(in.ResourceAttributes))
        out.NonResourceAttributes = (*authorizationv1.NonResourceAttributes)(unsafe.Pointer(in.NonResourceAttributes))
        return nil
}

// Convert_authorization_SelfSubjectAccessReviewSpec_To_v1_SelfSubjectAccessReviewSpec is an autogenerated conversion function.
func Convert_authorization_SelfSubjectAccessReviewSpec_To_v1_SelfSubjectAccessReviewSpec(in *authorization.SelfSubjectAccessReviewSpec, out *authorizationv1.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
        return autoConvert_authorization_SelfSubjectAccessReviewSpec_To_v1_SelfSubjectAccessReviewSpec(in, out, s)
}

func autoConvert_v1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview(in *authorizationv1.SelfSubjectRulesReview, out *authorization.SelfSubjectRulesReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview is an autogenerated conversion function.
func Convert_v1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview(in *authorizationv1.SelfSubjectRulesReview, out *authorization.SelfSubjectRulesReview, s conversion.Scope) error {
        return autoConvert_v1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview(in, out, s)
}

func autoConvert_authorization_SelfSubjectRulesReview_To_v1_SelfSubjectRulesReview(in *authorization.SelfSubjectRulesReview, out *authorizationv1.SelfSubjectRulesReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authorization_SelfSubjectRulesReviewSpec_To_v1_SelfSubjectRulesReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authorization_SubjectRulesReviewStatus_To_v1_SubjectRulesReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authorization_SelfSubjectRulesReview_To_v1_SelfSubjectRulesReview is an autogenerated conversion function.
func Convert_authorization_SelfSubjectRulesReview_To_v1_SelfSubjectRulesReview(in *authorization.SelfSubjectRulesReview, out *authorizationv1.SelfSubjectRulesReview, s conversion.Scope) error {
        return autoConvert_authorization_SelfSubjectRulesReview_To_v1_SelfSubjectRulesReview(in, out, s)
}

func autoConvert_v1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(in *authorizationv1.SelfSubjectRulesReviewSpec, out *authorization.SelfSubjectRulesReviewSpec, s conversion.Scope) error {
        out.Namespace = in.Namespace
        return nil
}

// Convert_v1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec is an autogenerated conversion function.
func Convert_v1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(in *authorizationv1.SelfSubjectRulesReviewSpec, out *authorization.SelfSubjectRulesReviewSpec, s conversion.Scope) error {
        return autoConvert_v1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(in, out, s)
}

func autoConvert_authorization_SelfSubjectRulesReviewSpec_To_v1_SelfSubjectRulesReviewSpec(in *authorization.SelfSubjectRulesReviewSpec, out *authorizationv1.SelfSubjectRulesReviewSpec, s conversion.Scope) error {
        out.Namespace = in.Namespace
        return nil
}

// Convert_authorization_SelfSubjectRulesReviewSpec_To_v1_SelfSubjectRulesReviewSpec is an autogenerated conversion function.
func Convert_authorization_SelfSubjectRulesReviewSpec_To_v1_SelfSubjectRulesReviewSpec(in *authorization.SelfSubjectRulesReviewSpec, out *authorizationv1.SelfSubjectRulesReviewSpec, s conversion.Scope) error {
        return autoConvert_authorization_SelfSubjectRulesReviewSpec_To_v1_SelfSubjectRulesReviewSpec(in, out, s)
}

func autoConvert_v1_SubjectAccessReview_To_authorization_SubjectAccessReview(in *authorizationv1.SubjectAccessReview, out *authorization.SubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_SubjectAccessReview_To_authorization_SubjectAccessReview is an autogenerated conversion function.
func Convert_v1_SubjectAccessReview_To_authorization_SubjectAccessReview(in *authorizationv1.SubjectAccessReview, out *authorization.SubjectAccessReview, s conversion.Scope) error {
        return autoConvert_v1_SubjectAccessReview_To_authorization_SubjectAccessReview(in, out, s)
}

func autoConvert_authorization_SubjectAccessReview_To_v1_SubjectAccessReview(in *authorization.SubjectAccessReview, out *authorizationv1.SubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authorization_SubjectAccessReviewSpec_To_v1_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authorization_SubjectAccessReviewStatus_To_v1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authorization_SubjectAccessReview_To_v1_SubjectAccessReview is an autogenerated conversion function.
func Convert_authorization_SubjectAccessReview_To_v1_SubjectAccessReview(in *authorization.SubjectAccessReview, out *authorizationv1.SubjectAccessReview, s conversion.Scope) error {
        return autoConvert_authorization_SubjectAccessReview_To_v1_SubjectAccessReview(in, out, s)
}

func autoConvert_v1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in *authorizationv1.SubjectAccessReviewSpec, out *authorization.SubjectAccessReviewSpec, s conversion.Scope) error {
        out.ResourceAttributes = (*authorization.ResourceAttributes)(unsafe.Pointer(in.ResourceAttributes))
        out.NonResourceAttributes = (*authorization.NonResourceAttributes)(unsafe.Pointer(in.NonResourceAttributes))
        out.User = in.User
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]authorization.ExtraValue)(unsafe.Pointer(&in.Extra))
        out.UID = in.UID
        return nil
}

// Convert_v1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec is an autogenerated conversion function.
func Convert_v1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in *authorizationv1.SubjectAccessReviewSpec, out *authorization.SubjectAccessReviewSpec, s conversion.Scope) error {
        return autoConvert_v1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in, out, s)
}

func autoConvert_authorization_SubjectAccessReviewSpec_To_v1_SubjectAccessReviewSpec(in *authorization.SubjectAccessReviewSpec, out *authorizationv1.SubjectAccessReviewSpec, s conversion.Scope) error {
        out.ResourceAttributes = (*authorizationv1.ResourceAttributes)(unsafe.Pointer(in.ResourceAttributes))
        out.NonResourceAttributes = (*authorizationv1.NonResourceAttributes)(unsafe.Pointer(in.NonResourceAttributes))
        out.User = in.User
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]authorizationv1.ExtraValue)(unsafe.Pointer(&in.Extra))
        out.UID = in.UID
        return nil
}

// Convert_authorization_SubjectAccessReviewSpec_To_v1_SubjectAccessReviewSpec is an autogenerated conversion function.
func Convert_authorization_SubjectAccessReviewSpec_To_v1_SubjectAccessReviewSpec(in *authorization.SubjectAccessReviewSpec, out *authorizationv1.SubjectAccessReviewSpec, s conversion.Scope) error {
        return autoConvert_authorization_SubjectAccessReviewSpec_To_v1_SubjectAccessReviewSpec(in, out, s)
}

func autoConvert_v1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in *authorizationv1.SubjectAccessReviewStatus, out *authorization.SubjectAccessReviewStatus, s conversion.Scope) error {
        out.Allowed = in.Allowed
        out.Denied = in.Denied
        out.Reason = in.Reason
        out.EvaluationError = in.EvaluationError
        return nil
}

// Convert_v1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus is an autogenerated conversion function.
func Convert_v1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in *authorizationv1.SubjectAccessReviewStatus, out *authorization.SubjectAccessReviewStatus, s conversion.Scope) error {
        return autoConvert_v1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in, out, s)
}

func autoConvert_authorization_SubjectAccessReviewStatus_To_v1_SubjectAccessReviewStatus(in *authorization.SubjectAccessReviewStatus, out *authorizationv1.SubjectAccessReviewStatus, s conversion.Scope) error {
        out.Allowed = in.Allowed
        out.Denied = in.Denied
        out.Reason = in.Reason
        out.EvaluationError = in.EvaluationError
        return nil
}

// Convert_authorization_SubjectAccessReviewStatus_To_v1_SubjectAccessReviewStatus is an autogenerated conversion function.
func Convert_authorization_SubjectAccessReviewStatus_To_v1_SubjectAccessReviewStatus(in *authorization.SubjectAccessReviewStatus, out *authorizationv1.SubjectAccessReviewStatus, s conversion.Scope) error {
        return autoConvert_authorization_SubjectAccessReviewStatus_To_v1_SubjectAccessReviewStatus(in, out, s)
}

func autoConvert_v1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(in *authorizationv1.SubjectRulesReviewStatus, out *authorization.SubjectRulesReviewStatus, s conversion.Scope) error {
        out.ResourceRules = *(*[]authorization.ResourceRule)(unsafe.Pointer(&in.ResourceRules))
        out.NonResourceRules = *(*[]authorization.NonResourceRule)(unsafe.Pointer(&in.NonResourceRules))
        out.Incomplete = in.Incomplete
        out.EvaluationError = in.EvaluationError
        return nil
}

// Convert_v1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus is an autogenerated conversion function.
func Convert_v1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(in *authorizationv1.SubjectRulesReviewStatus, out *authorization.SubjectRulesReviewStatus, s conversion.Scope) error {
        return autoConvert_v1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(in, out, s)
}

func autoConvert_authorization_SubjectRulesReviewStatus_To_v1_SubjectRulesReviewStatus(in *authorization.SubjectRulesReviewStatus, out *authorizationv1.SubjectRulesReviewStatus, s conversion.Scope) error {
        out.ResourceRules = *(*[]authorizationv1.ResourceRule)(unsafe.Pointer(&in.ResourceRules))
        out.NonResourceRules = *(*[]authorizationv1.NonResourceRule)(unsafe.Pointer(&in.NonResourceRules))
        out.Incomplete = in.Incomplete
        out.EvaluationError = in.EvaluationError
        return nil
}

// Convert_authorization_SubjectRulesReviewStatus_To_v1_SubjectRulesReviewStatus is an autogenerated conversion function.
func Convert_authorization_SubjectRulesReviewStatus_To_v1_SubjectRulesReviewStatus(in *authorization.SubjectRulesReviewStatus, out *authorizationv1.SubjectRulesReviewStatus, s conversion.Scope) error {
        return autoConvert_authorization_SubjectRulesReviewStatus_To_v1_SubjectRulesReviewStatus(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        authorizationv1beta1 "k8s.io/api/authorization/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "authorization.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &authorizationv1beta1.SchemeBuilder
        // AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        v1 "k8s.io/api/authorization/v1"
        authorizationv1beta1 "k8s.io/api/authorization/v1beta1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        authorization "k8s.io/kubernetes/pkg/apis/authorization"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.LocalSubjectAccessReview)(nil), (*authorization.LocalSubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(a.(*authorizationv1beta1.LocalSubjectAccessReview), b.(*authorization.LocalSubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.LocalSubjectAccessReview)(nil), (*authorizationv1beta1.LocalSubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview(a.(*authorization.LocalSubjectAccessReview), b.(*authorizationv1beta1.LocalSubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.NonResourceAttributes)(nil), (*authorization.NonResourceAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(a.(*authorizationv1beta1.NonResourceAttributes), b.(*authorization.NonResourceAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.NonResourceAttributes)(nil), (*authorizationv1beta1.NonResourceAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(a.(*authorization.NonResourceAttributes), b.(*authorizationv1beta1.NonResourceAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.NonResourceRule)(nil), (*authorization.NonResourceRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NonResourceRule_To_authorization_NonResourceRule(a.(*authorizationv1beta1.NonResourceRule), b.(*authorization.NonResourceRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.NonResourceRule)(nil), (*authorizationv1beta1.NonResourceRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_NonResourceRule_To_v1beta1_NonResourceRule(a.(*authorization.NonResourceRule), b.(*authorizationv1beta1.NonResourceRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.ResourceAttributes)(nil), (*authorization.ResourceAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(a.(*authorizationv1beta1.ResourceAttributes), b.(*authorization.ResourceAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.ResourceAttributes)(nil), (*authorizationv1beta1.ResourceAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(a.(*authorization.ResourceAttributes), b.(*authorizationv1beta1.ResourceAttributes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.ResourceRule)(nil), (*authorization.ResourceRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ResourceRule_To_authorization_ResourceRule(a.(*authorizationv1beta1.ResourceRule), b.(*authorization.ResourceRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.ResourceRule)(nil), (*authorizationv1beta1.ResourceRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_ResourceRule_To_v1beta1_ResourceRule(a.(*authorization.ResourceRule), b.(*authorizationv1beta1.ResourceRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.SelfSubjectAccessReview)(nil), (*authorization.SelfSubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(a.(*authorizationv1beta1.SelfSubjectAccessReview), b.(*authorization.SelfSubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SelfSubjectAccessReview)(nil), (*authorizationv1beta1.SelfSubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview(a.(*authorization.SelfSubjectAccessReview), b.(*authorizationv1beta1.SelfSubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.SelfSubjectAccessReviewSpec)(nil), (*authorization.SelfSubjectAccessReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(a.(*authorizationv1beta1.SelfSubjectAccessReviewSpec), b.(*authorization.SelfSubjectAccessReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SelfSubjectAccessReviewSpec)(nil), (*authorizationv1beta1.SelfSubjectAccessReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(a.(*authorization.SelfSubjectAccessReviewSpec), b.(*authorizationv1beta1.SelfSubjectAccessReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.SelfSubjectRulesReview)(nil), (*authorization.SelfSubjectRulesReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview(a.(*authorizationv1beta1.SelfSubjectRulesReview), b.(*authorization.SelfSubjectRulesReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SelfSubjectRulesReview)(nil), (*authorizationv1beta1.SelfSubjectRulesReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SelfSubjectRulesReview_To_v1beta1_SelfSubjectRulesReview(a.(*authorization.SelfSubjectRulesReview), b.(*authorizationv1beta1.SelfSubjectRulesReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.SelfSubjectRulesReviewSpec)(nil), (*authorization.SelfSubjectRulesReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(a.(*authorizationv1beta1.SelfSubjectRulesReviewSpec), b.(*authorization.SelfSubjectRulesReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SelfSubjectRulesReviewSpec)(nil), (*authorizationv1beta1.SelfSubjectRulesReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SelfSubjectRulesReviewSpec_To_v1beta1_SelfSubjectRulesReviewSpec(a.(*authorization.SelfSubjectRulesReviewSpec), b.(*authorizationv1beta1.SelfSubjectRulesReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.SubjectAccessReview)(nil), (*authorization.SubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview(a.(*authorizationv1beta1.SubjectAccessReview), b.(*authorization.SubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SubjectAccessReview)(nil), (*authorizationv1beta1.SubjectAccessReview)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview(a.(*authorization.SubjectAccessReview), b.(*authorizationv1beta1.SubjectAccessReview), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.SubjectAccessReviewSpec)(nil), (*authorization.SubjectAccessReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(a.(*authorizationv1beta1.SubjectAccessReviewSpec), b.(*authorization.SubjectAccessReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SubjectAccessReviewSpec)(nil), (*authorizationv1beta1.SubjectAccessReviewSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(a.(*authorization.SubjectAccessReviewSpec), b.(*authorizationv1beta1.SubjectAccessReviewSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.SubjectAccessReviewStatus)(nil), (*authorization.SubjectAccessReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(a.(*authorizationv1beta1.SubjectAccessReviewStatus), b.(*authorization.SubjectAccessReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SubjectAccessReviewStatus)(nil), (*authorizationv1beta1.SubjectAccessReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(a.(*authorization.SubjectAccessReviewStatus), b.(*authorizationv1beta1.SubjectAccessReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorizationv1beta1.SubjectRulesReviewStatus)(nil), (*authorization.SubjectRulesReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(a.(*authorizationv1beta1.SubjectRulesReviewStatus), b.(*authorization.SubjectRulesReviewStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*authorization.SubjectRulesReviewStatus)(nil), (*authorizationv1beta1.SubjectRulesReviewStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_authorization_SubjectRulesReviewStatus_To_v1beta1_SubjectRulesReviewStatus(a.(*authorization.SubjectRulesReviewStatus), b.(*authorizationv1beta1.SubjectRulesReviewStatus), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in *authorizationv1beta1.LocalSubjectAccessReview, out *authorization.LocalSubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview is an autogenerated conversion function.
func Convert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in *authorizationv1beta1.LocalSubjectAccessReview, out *authorization.LocalSubjectAccessReview, s conversion.Scope) error {
        return autoConvert_v1beta1_LocalSubjectAccessReview_To_authorization_LocalSubjectAccessReview(in, out, s)
}

func autoConvert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview(in *authorization.LocalSubjectAccessReview, out *authorizationv1beta1.LocalSubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview is an autogenerated conversion function.
func Convert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview(in *authorization.LocalSubjectAccessReview, out *authorizationv1beta1.LocalSubjectAccessReview, s conversion.Scope) error {
        return autoConvert_authorization_LocalSubjectAccessReview_To_v1beta1_LocalSubjectAccessReview(in, out, s)
}

func autoConvert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(in *authorizationv1beta1.NonResourceAttributes, out *authorization.NonResourceAttributes, s conversion.Scope) error {
        out.Path = in.Path
        out.Verb = in.Verb
        return nil
}

// Convert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes is an autogenerated conversion function.
func Convert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(in *authorizationv1beta1.NonResourceAttributes, out *authorization.NonResourceAttributes, s conversion.Scope) error {
        return autoConvert_v1beta1_NonResourceAttributes_To_authorization_NonResourceAttributes(in, out, s)
}

func autoConvert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(in *authorization.NonResourceAttributes, out *authorizationv1beta1.NonResourceAttributes, s conversion.Scope) error {
        out.Path = in.Path
        out.Verb = in.Verb
        return nil
}

// Convert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes is an autogenerated conversion function.
func Convert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(in *authorization.NonResourceAttributes, out *authorizationv1beta1.NonResourceAttributes, s conversion.Scope) error {
        return autoConvert_authorization_NonResourceAttributes_To_v1beta1_NonResourceAttributes(in, out, s)
}

func autoConvert_v1beta1_NonResourceRule_To_authorization_NonResourceRule(in *authorizationv1beta1.NonResourceRule, out *authorization.NonResourceRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs))
        return nil
}

// Convert_v1beta1_NonResourceRule_To_authorization_NonResourceRule is an autogenerated conversion function.
func Convert_v1beta1_NonResourceRule_To_authorization_NonResourceRule(in *authorizationv1beta1.NonResourceRule, out *authorization.NonResourceRule, s conversion.Scope) error {
        return autoConvert_v1beta1_NonResourceRule_To_authorization_NonResourceRule(in, out, s)
}

func autoConvert_authorization_NonResourceRule_To_v1beta1_NonResourceRule(in *authorization.NonResourceRule, out *authorizationv1beta1.NonResourceRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs))
        return nil
}

// Convert_authorization_NonResourceRule_To_v1beta1_NonResourceRule is an autogenerated conversion function.
func Convert_authorization_NonResourceRule_To_v1beta1_NonResourceRule(in *authorization.NonResourceRule, out *authorizationv1beta1.NonResourceRule, s conversion.Scope) error {
        return autoConvert_authorization_NonResourceRule_To_v1beta1_NonResourceRule(in, out, s)
}

func autoConvert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(in *authorizationv1beta1.ResourceAttributes, out *authorization.ResourceAttributes, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Verb = in.Verb
        out.Group = in.Group
        out.Version = in.Version
        out.Resource = in.Resource
        out.Subresource = in.Subresource
        out.Name = in.Name
        out.FieldSelector = (*authorization.FieldSelectorAttributes)(unsafe.Pointer(in.FieldSelector))
        out.LabelSelector = (*authorization.LabelSelectorAttributes)(unsafe.Pointer(in.LabelSelector))
        return nil
}

// Convert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes is an autogenerated conversion function.
func Convert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(in *authorizationv1beta1.ResourceAttributes, out *authorization.ResourceAttributes, s conversion.Scope) error {
        return autoConvert_v1beta1_ResourceAttributes_To_authorization_ResourceAttributes(in, out, s)
}

func autoConvert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(in *authorization.ResourceAttributes, out *authorizationv1beta1.ResourceAttributes, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Verb = in.Verb
        out.Group = in.Group
        out.Version = in.Version
        out.Resource = in.Resource
        out.Subresource = in.Subresource
        out.Name = in.Name
        out.FieldSelector = (*v1.FieldSelectorAttributes)(unsafe.Pointer(in.FieldSelector))
        out.LabelSelector = (*v1.LabelSelectorAttributes)(unsafe.Pointer(in.LabelSelector))
        return nil
}

// Convert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes is an autogenerated conversion function.
func Convert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(in *authorization.ResourceAttributes, out *authorizationv1beta1.ResourceAttributes, s conversion.Scope) error {
        return autoConvert_authorization_ResourceAttributes_To_v1beta1_ResourceAttributes(in, out, s)
}

func autoConvert_v1beta1_ResourceRule_To_authorization_ResourceRule(in *authorizationv1beta1.ResourceRule, out *authorization.ResourceRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.APIGroups = *(*[]string)(unsafe.Pointer(&in.APIGroups))
        out.Resources = *(*[]string)(unsafe.Pointer(&in.Resources))
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        return nil
}

// Convert_v1beta1_ResourceRule_To_authorization_ResourceRule is an autogenerated conversion function.
func Convert_v1beta1_ResourceRule_To_authorization_ResourceRule(in *authorizationv1beta1.ResourceRule, out *authorization.ResourceRule, s conversion.Scope) error {
        return autoConvert_v1beta1_ResourceRule_To_authorization_ResourceRule(in, out, s)
}

func autoConvert_authorization_ResourceRule_To_v1beta1_ResourceRule(in *authorization.ResourceRule, out *authorizationv1beta1.ResourceRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.APIGroups = *(*[]string)(unsafe.Pointer(&in.APIGroups))
        out.Resources = *(*[]string)(unsafe.Pointer(&in.Resources))
        out.ResourceNames = *(*[]string)(unsafe.Pointer(&in.ResourceNames))
        return nil
}

// Convert_authorization_ResourceRule_To_v1beta1_ResourceRule is an autogenerated conversion function.
func Convert_authorization_ResourceRule_To_v1beta1_ResourceRule(in *authorization.ResourceRule, out *authorizationv1beta1.ResourceRule, s conversion.Scope) error {
        return autoConvert_authorization_ResourceRule_To_v1beta1_ResourceRule(in, out, s)
}

func autoConvert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in *authorizationv1beta1.SelfSubjectAccessReview, out *authorization.SelfSubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview is an autogenerated conversion function.
func Convert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in *authorizationv1beta1.SelfSubjectAccessReview, out *authorization.SelfSubjectAccessReview, s conversion.Scope) error {
        return autoConvert_v1beta1_SelfSubjectAccessReview_To_authorization_SelfSubjectAccessReview(in, out, s)
}

func autoConvert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview(in *authorization.SelfSubjectAccessReview, out *authorizationv1beta1.SelfSubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview is an autogenerated conversion function.
func Convert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview(in *authorization.SelfSubjectAccessReview, out *authorizationv1beta1.SelfSubjectAccessReview, s conversion.Scope) error {
        return autoConvert_authorization_SelfSubjectAccessReview_To_v1beta1_SelfSubjectAccessReview(in, out, s)
}

func autoConvert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in *authorizationv1beta1.SelfSubjectAccessReviewSpec, out *authorization.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
        out.ResourceAttributes = (*authorization.ResourceAttributes)(unsafe.Pointer(in.ResourceAttributes))
        out.NonResourceAttributes = (*authorization.NonResourceAttributes)(unsafe.Pointer(in.NonResourceAttributes))
        return nil
}

// Convert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec is an autogenerated conversion function.
func Convert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in *authorizationv1beta1.SelfSubjectAccessReviewSpec, out *authorization.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_SelfSubjectAccessReviewSpec_To_authorization_SelfSubjectAccessReviewSpec(in, out, s)
}

func autoConvert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(in *authorization.SelfSubjectAccessReviewSpec, out *authorizationv1beta1.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
        out.ResourceAttributes = (*authorizationv1beta1.ResourceAttributes)(unsafe.Pointer(in.ResourceAttributes))
        out.NonResourceAttributes = (*authorizationv1beta1.NonResourceAttributes)(unsafe.Pointer(in.NonResourceAttributes))
        return nil
}

// Convert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec is an autogenerated conversion function.
func Convert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(in *authorization.SelfSubjectAccessReviewSpec, out *authorizationv1beta1.SelfSubjectAccessReviewSpec, s conversion.Scope) error {
        return autoConvert_authorization_SelfSubjectAccessReviewSpec_To_v1beta1_SelfSubjectAccessReviewSpec(in, out, s)
}

func autoConvert_v1beta1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview(in *authorizationv1beta1.SelfSubjectRulesReview, out *authorization.SelfSubjectRulesReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview is an autogenerated conversion function.
func Convert_v1beta1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview(in *authorizationv1beta1.SelfSubjectRulesReview, out *authorization.SelfSubjectRulesReview, s conversion.Scope) error {
        return autoConvert_v1beta1_SelfSubjectRulesReview_To_authorization_SelfSubjectRulesReview(in, out, s)
}

func autoConvert_authorization_SelfSubjectRulesReview_To_v1beta1_SelfSubjectRulesReview(in *authorization.SelfSubjectRulesReview, out *authorizationv1beta1.SelfSubjectRulesReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authorization_SelfSubjectRulesReviewSpec_To_v1beta1_SelfSubjectRulesReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authorization_SubjectRulesReviewStatus_To_v1beta1_SubjectRulesReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authorization_SelfSubjectRulesReview_To_v1beta1_SelfSubjectRulesReview is an autogenerated conversion function.
func Convert_authorization_SelfSubjectRulesReview_To_v1beta1_SelfSubjectRulesReview(in *authorization.SelfSubjectRulesReview, out *authorizationv1beta1.SelfSubjectRulesReview, s conversion.Scope) error {
        return autoConvert_authorization_SelfSubjectRulesReview_To_v1beta1_SelfSubjectRulesReview(in, out, s)
}

func autoConvert_v1beta1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(in *authorizationv1beta1.SelfSubjectRulesReviewSpec, out *authorization.SelfSubjectRulesReviewSpec, s conversion.Scope) error {
        out.Namespace = in.Namespace
        return nil
}

// Convert_v1beta1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec is an autogenerated conversion function.
func Convert_v1beta1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(in *authorizationv1beta1.SelfSubjectRulesReviewSpec, out *authorization.SelfSubjectRulesReviewSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_SelfSubjectRulesReviewSpec_To_authorization_SelfSubjectRulesReviewSpec(in, out, s)
}

func autoConvert_authorization_SelfSubjectRulesReviewSpec_To_v1beta1_SelfSubjectRulesReviewSpec(in *authorization.SelfSubjectRulesReviewSpec, out *authorizationv1beta1.SelfSubjectRulesReviewSpec, s conversion.Scope) error {
        out.Namespace = in.Namespace
        return nil
}

// Convert_authorization_SelfSubjectRulesReviewSpec_To_v1beta1_SelfSubjectRulesReviewSpec is an autogenerated conversion function.
func Convert_authorization_SelfSubjectRulesReviewSpec_To_v1beta1_SelfSubjectRulesReviewSpec(in *authorization.SelfSubjectRulesReviewSpec, out *authorizationv1beta1.SelfSubjectRulesReviewSpec, s conversion.Scope) error {
        return autoConvert_authorization_SelfSubjectRulesReviewSpec_To_v1beta1_SelfSubjectRulesReviewSpec(in, out, s)
}

func autoConvert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview(in *authorizationv1beta1.SubjectAccessReview, out *authorization.SubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview is an autogenerated conversion function.
func Convert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview(in *authorizationv1beta1.SubjectAccessReview, out *authorization.SubjectAccessReview, s conversion.Scope) error {
        return autoConvert_v1beta1_SubjectAccessReview_To_authorization_SubjectAccessReview(in, out, s)
}

func autoConvert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview(in *authorization.SubjectAccessReview, out *authorizationv1beta1.SubjectAccessReview, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview is an autogenerated conversion function.
func Convert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview(in *authorization.SubjectAccessReview, out *authorizationv1beta1.SubjectAccessReview, s conversion.Scope) error {
        return autoConvert_authorization_SubjectAccessReview_To_v1beta1_SubjectAccessReview(in, out, s)
}

func autoConvert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in *authorizationv1beta1.SubjectAccessReviewSpec, out *authorization.SubjectAccessReviewSpec, s conversion.Scope) error {
        out.ResourceAttributes = (*authorization.ResourceAttributes)(unsafe.Pointer(in.ResourceAttributes))
        out.NonResourceAttributes = (*authorization.NonResourceAttributes)(unsafe.Pointer(in.NonResourceAttributes))
        out.User = in.User
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]authorization.ExtraValue)(unsafe.Pointer(&in.Extra))
        out.UID = in.UID
        return nil
}

// Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec is an autogenerated conversion function.
func Convert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in *authorizationv1beta1.SubjectAccessReviewSpec, out *authorization.SubjectAccessReviewSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_SubjectAccessReviewSpec_To_authorization_SubjectAccessReviewSpec(in, out, s)
}

func autoConvert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(in *authorization.SubjectAccessReviewSpec, out *authorizationv1beta1.SubjectAccessReviewSpec, s conversion.Scope) error {
        out.ResourceAttributes = (*authorizationv1beta1.ResourceAttributes)(unsafe.Pointer(in.ResourceAttributes))
        out.NonResourceAttributes = (*authorizationv1beta1.NonResourceAttributes)(unsafe.Pointer(in.NonResourceAttributes))
        out.User = in.User
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]authorizationv1beta1.ExtraValue)(unsafe.Pointer(&in.Extra))
        out.UID = in.UID
        return nil
}

// Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec is an autogenerated conversion function.
func Convert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(in *authorization.SubjectAccessReviewSpec, out *authorizationv1beta1.SubjectAccessReviewSpec, s conversion.Scope) error {
        return autoConvert_authorization_SubjectAccessReviewSpec_To_v1beta1_SubjectAccessReviewSpec(in, out, s)
}

func autoConvert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in *authorizationv1beta1.SubjectAccessReviewStatus, out *authorization.SubjectAccessReviewStatus, s conversion.Scope) error {
        out.Allowed = in.Allowed
        out.Denied = in.Denied
        out.Reason = in.Reason
        out.EvaluationError = in.EvaluationError
        return nil
}

// Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus is an autogenerated conversion function.
func Convert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in *authorizationv1beta1.SubjectAccessReviewStatus, out *authorization.SubjectAccessReviewStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_SubjectAccessReviewStatus_To_authorization_SubjectAccessReviewStatus(in, out, s)
}

func autoConvert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(in *authorization.SubjectAccessReviewStatus, out *authorizationv1beta1.SubjectAccessReviewStatus, s conversion.Scope) error {
        out.Allowed = in.Allowed
        out.Denied = in.Denied
        out.Reason = in.Reason
        out.EvaluationError = in.EvaluationError
        return nil
}

// Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus is an autogenerated conversion function.
func Convert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(in *authorization.SubjectAccessReviewStatus, out *authorizationv1beta1.SubjectAccessReviewStatus, s conversion.Scope) error {
        return autoConvert_authorization_SubjectAccessReviewStatus_To_v1beta1_SubjectAccessReviewStatus(in, out, s)
}

func autoConvert_v1beta1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(in *authorizationv1beta1.SubjectRulesReviewStatus, out *authorization.SubjectRulesReviewStatus, s conversion.Scope) error {
        out.ResourceRules = *(*[]authorization.ResourceRule)(unsafe.Pointer(&in.ResourceRules))
        out.NonResourceRules = *(*[]authorization.NonResourceRule)(unsafe.Pointer(&in.NonResourceRules))
        out.Incomplete = in.Incomplete
        out.EvaluationError = in.EvaluationError
        return nil
}

// Convert_v1beta1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus is an autogenerated conversion function.
func Convert_v1beta1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(in *authorizationv1beta1.SubjectRulesReviewStatus, out *authorization.SubjectRulesReviewStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_SubjectRulesReviewStatus_To_authorization_SubjectRulesReviewStatus(in, out, s)
}

func autoConvert_authorization_SubjectRulesReviewStatus_To_v1beta1_SubjectRulesReviewStatus(in *authorization.SubjectRulesReviewStatus, out *authorizationv1beta1.SubjectRulesReviewStatus, s conversion.Scope) error {
        out.ResourceRules = *(*[]authorizationv1beta1.ResourceRule)(unsafe.Pointer(&in.ResourceRules))
        out.NonResourceRules = *(*[]authorizationv1beta1.NonResourceRule)(unsafe.Pointer(&in.NonResourceRules))
        out.Incomplete = in.Incomplete
        out.EvaluationError = in.EvaluationError
        return nil
}

// Convert_authorization_SubjectRulesReviewStatus_To_v1beta1_SubjectRulesReviewStatus is an autogenerated conversion function.
func Convert_authorization_SubjectRulesReviewStatus_To_v1beta1_SubjectRulesReviewStatus(in *authorization.SubjectRulesReviewStatus, out *authorizationv1beta1.SubjectRulesReviewStatus, s conversion.Scope) error {
        return autoConvert_authorization_SubjectRulesReviewStatus_To_v1beta1_SubjectRulesReviewStatus(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package authorization

import (
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in ExtraValue) DeepCopyInto(out *ExtraValue) {
        {
                in := &in
                *out = make(ExtraValue, len(*in))
                copy(*out, *in)
                return
        }
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtraValue.
func (in ExtraValue) DeepCopy() ExtraValue {
        if in == nil {
                return nil
        }
        out := new(ExtraValue)
        in.DeepCopyInto(out)
        return *out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *FieldSelectorAttributes) DeepCopyInto(out *FieldSelectorAttributes) {
        *out = *in
        if in.Requirements != nil {
                in, out := &in.Requirements, &out.Requirements
                *out = make([]v1.FieldSelectorRequirement, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FieldSelectorAttributes.
func (in *FieldSelectorAttributes) DeepCopy() *FieldSelectorAttributes {
        if in == nil {
                return nil
        }
        out := new(FieldSelectorAttributes)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LabelSelectorAttributes) DeepCopyInto(out *LabelSelectorAttributes) {
        *out = *in
        if in.Requirements != nil {
                in, out := &in.Requirements, &out.Requirements
                *out = make([]v1.LabelSelectorRequirement, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LabelSelectorAttributes.
func (in *LabelSelectorAttributes) DeepCopy() *LabelSelectorAttributes {
        if in == nil {
                return nil
        }
        out := new(LabelSelectorAttributes)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LocalSubjectAccessReview) DeepCopyInto(out *LocalSubjectAccessReview) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        out.Status = in.Status
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LocalSubjectAccessReview.
func (in *LocalSubjectAccessReview) DeepCopy() *LocalSubjectAccessReview {
        if in == nil {
                return nil
        }
        out := new(LocalSubjectAccessReview)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *LocalSubjectAccessReview) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NonResourceAttributes) DeepCopyInto(out *NonResourceAttributes) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NonResourceAttributes.
func (in *NonResourceAttributes) DeepCopy() *NonResourceAttributes {
        if in == nil {
                return nil
        }
        out := new(NonResourceAttributes)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NonResourceRule) DeepCopyInto(out *NonResourceRule) {
        *out = *in
        if in.Verbs != nil {
                in, out := &in.Verbs, &out.Verbs
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.NonResourceURLs != nil {
                in, out := &in.NonResourceURLs, &out.NonResourceURLs
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NonResourceRule.
func (in *NonResourceRule) DeepCopy() *NonResourceRule {
        if in == nil {
                return nil
        }
        out := new(NonResourceRule)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceAttributes) DeepCopyInto(out *ResourceAttributes) {
        *out = *in
        if in.FieldSelector != nil {
                in, out := &in.FieldSelector, &out.FieldSelector
                *out = new(FieldSelectorAttributes)
                (*in).DeepCopyInto(*out)
        }
        if in.LabelSelector != nil {
                in, out := &in.LabelSelector, &out.LabelSelector
                *out = new(LabelSelectorAttributes)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceAttributes.
func (in *ResourceAttributes) DeepCopy() *ResourceAttributes {
        if in == nil {
                return nil
        }
        out := new(ResourceAttributes)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceRule) DeepCopyInto(out *ResourceRule) {
        *out = *in
        if in.Verbs != nil {
                in, out := &in.Verbs, &out.Verbs
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.APIGroups != nil {
                in, out := &in.APIGroups, &out.APIGroups
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Resources != nil {
                in, out := &in.Resources, &out.Resources
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.ResourceNames != nil {
                in, out := &in.ResourceNames, &out.ResourceNames
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceRule.
func (in *ResourceRule) DeepCopy() *ResourceRule {
        if in == nil {
                return nil
        }
        out := new(ResourceRule)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SelfSubjectAccessReview) DeepCopyInto(out *SelfSubjectAccessReview) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        out.Status = in.Status
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SelfSubjectAccessReview.
func (in *SelfSubjectAccessReview) DeepCopy() *SelfSubjectAccessReview {
        if in == nil {
                return nil
        }
        out := new(SelfSubjectAccessReview)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *SelfSubjectAccessReview) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SelfSubjectAccessReviewSpec) DeepCopyInto(out *SelfSubjectAccessReviewSpec) {
        *out = *in
        if in.ResourceAttributes != nil {
                in, out := &in.ResourceAttributes, &out.ResourceAttributes
                *out = new(ResourceAttributes)
                (*in).DeepCopyInto(*out)
        }
        if in.NonResourceAttributes != nil {
                in, out := &in.NonResourceAttributes, &out.NonResourceAttributes
                *out = new(NonResourceAttributes)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SelfSubjectAccessReviewSpec.
func (in *SelfSubjectAccessReviewSpec) DeepCopy() *SelfSubjectAccessReviewSpec {
        if in == nil {
                return nil
        }
        out := new(SelfSubjectAccessReviewSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SelfSubjectRulesReview) DeepCopyInto(out *SelfSubjectRulesReview) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        out.Spec = in.Spec
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SelfSubjectRulesReview.
func (in *SelfSubjectRulesReview) DeepCopy() *SelfSubjectRulesReview {
        if in == nil {
                return nil
        }
        out := new(SelfSubjectRulesReview)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *SelfSubjectRulesReview) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SelfSubjectRulesReviewSpec) DeepCopyInto(out *SelfSubjectRulesReviewSpec) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SelfSubjectRulesReviewSpec.
func (in *SelfSubjectRulesReviewSpec) DeepCopy() *SelfSubjectRulesReviewSpec {
        if in == nil {
                return nil
        }
        out := new(SelfSubjectRulesReviewSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SubjectAccessReview) DeepCopyInto(out *SubjectAccessReview) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        out.Status = in.Status
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubjectAccessReview.
func (in *SubjectAccessReview) DeepCopy() *SubjectAccessReview {
        if in == nil {
                return nil
        }
        out := new(SubjectAccessReview)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *SubjectAccessReview) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SubjectAccessReviewSpec) DeepCopyInto(out *SubjectAccessReviewSpec) {
        *out = *in
        if in.ResourceAttributes != nil {
                in, out := &in.ResourceAttributes, &out.ResourceAttributes
                *out = new(ResourceAttributes)
                (*in).DeepCopyInto(*out)
        }
        if in.NonResourceAttributes != nil {
                in, out := &in.NonResourceAttributes, &out.NonResourceAttributes
                *out = new(NonResourceAttributes)
                **out = **in
        }
        if in.Groups != nil {
                in, out := &in.Groups, &out.Groups
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Extra != nil {
                in, out := &in.Extra, &out.Extra
                *out = make(map[string]ExtraValue, len(*in))
                for key, val := range *in {
                        var outVal []string
                        if val == nil {
                                (*out)[key] = nil
                        } else {
                                in, out := &val, &outVal
                                *out = make(ExtraValue, len(*in))
                                copy(*out, *in)
                        }
                        (*out)[key] = outVal
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubjectAccessReviewSpec.
func (in *SubjectAccessReviewSpec) DeepCopy() *SubjectAccessReviewSpec {
        if in == nil {
                return nil
        }
        out := new(SubjectAccessReviewSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SubjectAccessReviewStatus) DeepCopyInto(out *SubjectAccessReviewStatus) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubjectAccessReviewStatus.
func (in *SubjectAccessReviewStatus) DeepCopy() *SubjectAccessReviewStatus {
        if in == nil {
                return nil
        }
        out := new(SubjectAccessReviewStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SubjectRulesReviewStatus) DeepCopyInto(out *SubjectRulesReviewStatus) {
        *out = *in
        if in.ResourceRules != nil {
                in, out := &in.ResourceRules, &out.ResourceRules
                *out = make([]ResourceRule, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.NonResourceRules != nil {
                in, out := &in.NonResourceRules, &out.NonResourceRules
                *out = make([]NonResourceRule, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SubjectRulesReviewStatus.
func (in *SubjectRulesReviewStatus) DeepCopy() *SubjectRulesReviewStatus {
        if in == nil {
                return nil
        }
        out := new(SubjectRulesReviewStatus)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        "sigs.k8s.io/randfill"

        "k8s.io/apimachinery/pkg/api/resource"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/utils/ptr"
)

// Funcs returns the fuzzer functions for the autoscaling api group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(s *autoscaling.ScaleStatus, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again

                        // ensure we have a valid selector
                        metaSelector := &metav1.LabelSelector{}
                        c.Fill(metaSelector)
                        labelSelector, _ := metav1.LabelSelectorAsSelector(metaSelector)
                        s.Selector = labelSelector.String()
                },
                func(s *autoscaling.HorizontalPodAutoscalerSpec, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again
                        s.MinReplicas = ptr.To[int32](c.Rand.Int31())

                        randomQuantity := func() resource.Quantity {
                                var q resource.Quantity
                                c.Fill(&q)
                                // precalc the string for benchmarking purposes
                                _ = q.String()
                                return q
                        }

                        var podMetricID autoscaling.MetricIdentifier
                        var objMetricID autoscaling.MetricIdentifier
                        c.Fill(&podMetricID)
                        c.Fill(&objMetricID)

                        targetUtilization := int32(c.Uint64())
                        averageValue := randomQuantity()
                        s.Metrics = []autoscaling.MetricSpec{
                                {
                                        Type: autoscaling.PodsMetricSourceType,
                                        Pods: &autoscaling.PodsMetricSource{
                                                Metric: podMetricID,
                                                Target: autoscaling.MetricTarget{
                                                        Type:         autoscaling.AverageValueMetricType,
                                                        AverageValue: &averageValue,
                                                },
                                        },
                                },
                                {
                                        Type: autoscaling.ObjectMetricSourceType,
                                        Object: &autoscaling.ObjectMetricSource{
                                                Metric: objMetricID,
                                                Target: autoscaling.MetricTarget{
                                                        Type:  autoscaling.ValueMetricType,
                                                        Value: &averageValue,
                                                },
                                        },
                                },
                                {
                                        Type: autoscaling.ResourceMetricSourceType,
                                        Resource: &autoscaling.ResourceMetricSource{
                                                Name: api.ResourceCPU,
                                                Target: autoscaling.MetricTarget{
                                                        Type:               autoscaling.UtilizationMetricType,
                                                        AverageUtilization: &targetUtilization,
                                                },
                                        },
                                },
                        }
                        stabilizationWindow := int32(c.Uint64())
                        maxPolicy := autoscaling.MaxPolicySelect
                        minPolicy := autoscaling.MinPolicySelect
                        s.Behavior = &autoscaling.HorizontalPodAutoscalerBehavior{
                                ScaleUp: &autoscaling.HPAScalingRules{
                                        StabilizationWindowSeconds: &stabilizationWindow,
                                        SelectPolicy:               &maxPolicy,
                                        Policies: []autoscaling.HPAScalingPolicy{
                                                {
                                                        Type:          autoscaling.PodsScalingPolicy,
                                                        Value:         int32(c.Uint64()),
                                                        PeriodSeconds: int32(c.Uint64()),
                                                },
                                                {
                                                        Type:          autoscaling.PercentScalingPolicy,
                                                        Value:         int32(c.Uint64()),
                                                        PeriodSeconds: int32(c.Uint64()),
                                                },
                                        },
                                },
                                ScaleDown: &autoscaling.HPAScalingRules{
                                        StabilizationWindowSeconds: &stabilizationWindow,
                                        SelectPolicy:               &minPolicy,
                                        Policies: []autoscaling.HPAScalingPolicy{
                                                {
                                                        Type:          autoscaling.PodsScalingPolicy,
                                                        Value:         int32(c.Uint64()),
                                                        PeriodSeconds: int32(c.Uint64()),
                                                },
                                                {
                                                        Type:          autoscaling.PercentScalingPolicy,
                                                        Value:         int32(c.Uint64()),
                                                        PeriodSeconds: int32(c.Uint64()),
                                                },
                                        },
                                },
                        }
                },
                func(s *autoscaling.HorizontalPodAutoscalerStatus, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again
                        randomQuantity := func() resource.Quantity {
                                var q resource.Quantity
                                c.Fill(&q)
                                // precalc the string for benchmarking purposes
                                _ = q.String()
                                return q
                        }
                        averageValue := randomQuantity()
                        currentUtilization := int32(c.Uint64())
                        s.CurrentMetrics = []autoscaling.MetricStatus{
                                {
                                        Type: autoscaling.PodsMetricSourceType,
                                        Pods: &autoscaling.PodsMetricStatus{
                                                Metric: autoscaling.MetricIdentifier{
                                                        Name: c.String(0),
                                                },
                                                Current: autoscaling.MetricValueStatus{
                                                        AverageValue: &averageValue,
                                                },
                                        },
                                },
                                {
                                        Type: autoscaling.ResourceMetricSourceType,
                                        Resource: &autoscaling.ResourceMetricStatus{
                                                Name: api.ResourceCPU,
                                                Current: autoscaling.MetricValueStatus{
                                                        AverageUtilization: &currentUtilization,
                                                        AverageValue:       &averageValue,
                                                },
                                        },
                                },
                        }
                },
        }
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package autoscaling

// DropRoundTripHorizontalPodAutoscalerAnnotations removes any annotations used to
// serialize round-tripped fields from HorizontalPodAutoscaler later API versions,
// and returns false if no changes were made and the original input object was returned.
//
// It should always be called when converting internal -> external versions, prior
// to setting any of the custom annotations:
//
//        annotations, copiedAnnotations := DropRoundTripHorizontalPodAutoscalerAnnotations(externalObj.Annotations)
//        externalObj.Annotations = annotations
//
//        if internal.SomeField != nil {
//          if !copiedAnnotations {
//            externalObj.Annotations = DeepCopyStringMap(externalObj.Annotations)
//            copiedAnnotations = true
//          }
//          externalObj.Annotations[...] = json.Marshal(...)
//        }
func DropRoundTripHorizontalPodAutoscalerAnnotations(in map[string]string) (out map[string]string, copied bool) {
        _, hasMetricsSpecs := in[MetricSpecsAnnotation]
        _, hasBehaviorSpecs := in[BehaviorSpecsAnnotation]
        _, hasToleranceScaleDown := in[ToleranceScaleDownAnnotation]
        _, hasToleranceScaleUp := in[ToleranceScaleUpAnnotation]
        _, hasMetricsStatuses := in[MetricStatusesAnnotation]
        _, hasConditions := in[HorizontalPodAutoscalerConditionsAnnotation]
        if hasMetricsSpecs || hasBehaviorSpecs || hasToleranceScaleDown || hasToleranceScaleUp || hasMetricsStatuses || hasConditions {
                out = DeepCopyStringMap(in)
                delete(out, MetricSpecsAnnotation)
                delete(out, BehaviorSpecsAnnotation)
                delete(out, ToleranceScaleDownAnnotation)
                delete(out, ToleranceScaleUpAnnotation)
                delete(out, MetricStatusesAnnotation)
                delete(out, HorizontalPodAutoscalerConditionsAnnotation)
                return out, true
        }
        return in, false
}

// DeepCopyStringMap returns a copy of the input map.
// If input is nil, an empty map is returned.
func DeepCopyStringMap(in map[string]string) map[string]string {
        out := make(map[string]string, len(in))
        for k, v := range in {
                out[k] = v
        }
        return out
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

// Package install installs the experimental API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/kubernetes/pkg/apis/autoscaling/v1"
        "k8s.io/kubernetes/pkg/apis/autoscaling/v2"
        "k8s.io/kubernetes/pkg/apis/autoscaling/v2beta1"
        "k8s.io/kubernetes/pkg/apis/autoscaling/v2beta2"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(autoscaling.AddToScheme(scheme))
        utilruntime.Must(v2beta2.AddToScheme(scheme))
        utilruntime.Must(v2.AddToScheme(scheme))
        utilruntime.Must(v2beta1.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v2.SchemeGroupVersion, v1.SchemeGroupVersion, v2beta1.SchemeGroupVersion, v2beta2.SchemeGroupVersion))
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package autoscaling

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "autoscaling"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder points to a list of functions added to Scheme.
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme applies all the stored functions to the scheme.
        AddToScheme = SchemeBuilder.AddToScheme
)

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &Scale{},
                &HorizontalPodAutoscaler{},
                &HorizontalPodAutoscalerList{},
        )
        return nil
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1

import (
        "encoding/json"

        autoscalingv1 "k8s.io/api/autoscaling/v1"

        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/kubernetes/pkg/apis/core"
)

func Convert_autoscaling_MetricTarget_To_v1_CrossVersionObjectReference(in *autoscaling.MetricTarget, out *autoscalingv1.CrossVersionObjectReference, s conversion.Scope) error {
        return nil
}

func Convert_v1_CrossVersionObjectReference_To_autoscaling_MetricTarget(in *autoscalingv1.CrossVersionObjectReference, out *autoscaling.MetricTarget, s conversion.Scope) error {
        return nil
}

func Convert_autoscaling_ExternalMetricSource_To_v1_ExternalMetricSource(in *autoscaling.ExternalMetricSource, out *autoscalingv1.ExternalMetricSource, s conversion.Scope) error {
        out.MetricName = in.Metric.Name
        out.TargetValue = in.Target.Value
        out.TargetAverageValue = in.Target.AverageValue
        out.MetricSelector = in.Metric.Selector
        return nil
}

func Convert_v1_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in *autoscalingv1.ExternalMetricSource, out *autoscaling.ExternalMetricSource, s conversion.Scope) error {
        value := in.TargetValue
        averageValue := in.TargetAverageValue
        var metricType autoscaling.MetricTargetType
        if value == nil {
                metricType = autoscaling.AverageValueMetricType
        } else {
                metricType = autoscaling.ValueMetricType
        }
        out.Target = autoscaling.MetricTarget{
                Type:         metricType,
                Value:        value,
                AverageValue: averageValue,
        }

        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.MetricSelector,
        }
        return nil
}

func Convert_autoscaling_ObjectMetricSource_To_v1_ObjectMetricSource(in *autoscaling.ObjectMetricSource, out *autoscalingv1.ObjectMetricSource, s conversion.Scope) error {
        if in.Target.Value != nil {
                out.TargetValue = *in.Target.Value
        }
        out.AverageValue = in.Target.AverageValue
        out.Target = autoscalingv1.CrossVersionObjectReference{
                Kind:       in.DescribedObject.Kind,
                Name:       in.DescribedObject.Name,
                APIVersion: in.DescribedObject.APIVersion,
        }
        out.MetricName = in.Metric.Name
        out.Selector = in.Metric.Selector
        return nil
}

func Convert_v1_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in *autoscalingv1.ObjectMetricSource, out *autoscaling.ObjectMetricSource, s conversion.Scope) error {
        var metricType autoscaling.MetricTargetType
        if in.AverageValue == nil {
                metricType = autoscaling.ValueMetricType
        } else {
                metricType = autoscaling.AverageValueMetricType
        }

        out.Target = autoscaling.MetricTarget{
                Type:         metricType,
                Value:        &in.TargetValue,
                AverageValue: in.AverageValue,
        }
        out.DescribedObject = autoscaling.CrossVersionObjectReference{
                Kind:       in.Target.Kind,
                Name:       in.Target.Name,
                APIVersion: in.Target.APIVersion,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.Selector,
        }
        return nil
}

func Convert_autoscaling_PodsMetricSource_To_v1_PodsMetricSource(in *autoscaling.PodsMetricSource, out *autoscalingv1.PodsMetricSource, s conversion.Scope) error {
        if in.Target.AverageValue != nil {
                out.TargetAverageValue = *in.Target.AverageValue
        }

        out.MetricName = in.Metric.Name
        out.Selector = in.Metric.Selector
        return nil
}

func Convert_v1_PodsMetricSource_To_autoscaling_PodsMetricSource(in *autoscalingv1.PodsMetricSource, out *autoscaling.PodsMetricSource, s conversion.Scope) error {
        metricType := autoscaling.AverageValueMetricType

        out.Target = autoscaling.MetricTarget{
                Type:         metricType,
                AverageValue: &in.TargetAverageValue,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.Selector,
        }
        return nil
}

func Convert_autoscaling_ExternalMetricStatus_To_v1_ExternalMetricStatus(in *autoscaling.ExternalMetricStatus, out *autoscalingv1.ExternalMetricStatus, s conversion.Scope) error {
        out.MetricName = in.Metric.Name
        if in.Current.Value != nil {
                out.CurrentValue = *in.Current.Value
        }
        if in.Current.AverageValue != nil {
                out.CurrentAverageValue = in.Current.AverageValue
        }
        out.MetricSelector = in.Metric.Selector
        return nil
}

func Convert_v1_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in *autoscalingv1.ExternalMetricStatus, out *autoscaling.ExternalMetricStatus, s conversion.Scope) error {
        value := in.CurrentValue
        averageValue := in.CurrentAverageValue
        out.Current = autoscaling.MetricValueStatus{
                Value:        &value,
                AverageValue: averageValue,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.MetricSelector,
        }
        return nil
}

func Convert_autoscaling_ObjectMetricStatus_To_v1_ObjectMetricStatus(in *autoscaling.ObjectMetricStatus, out *autoscalingv1.ObjectMetricStatus, s conversion.Scope) error {
        if in.Current.Value != nil {
                out.CurrentValue = *in.Current.Value
        }
        if in.Current.AverageValue != nil {
                currentAverageValue := *in.Current.AverageValue
                out.AverageValue = &currentAverageValue
        }
        out.Target = autoscalingv1.CrossVersionObjectReference{
                Kind:       in.DescribedObject.Kind,
                Name:       in.DescribedObject.Name,
                APIVersion: in.DescribedObject.APIVersion,
        }
        out.MetricName = in.Metric.Name
        out.Selector = in.Metric.Selector
        return nil
}

func Convert_v1_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in *autoscalingv1.ObjectMetricStatus, out *autoscaling.ObjectMetricStatus, s conversion.Scope) error {
        out.Current = autoscaling.MetricValueStatus{
                Value:        &in.CurrentValue,
                AverageValue: in.AverageValue,
        }
        out.DescribedObject = autoscaling.CrossVersionObjectReference{
                Kind:       in.Target.Kind,
                Name:       in.Target.Name,
                APIVersion: in.Target.APIVersion,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.Selector,
        }
        return nil
}

func Convert_autoscaling_PodsMetricStatus_To_v1_PodsMetricStatus(in *autoscaling.PodsMetricStatus, out *autoscalingv1.PodsMetricStatus, s conversion.Scope) error {
        if in.Current.AverageValue != nil {
                out.CurrentAverageValue = *in.Current.AverageValue
        }
        out.MetricName = in.Metric.Name
        out.Selector = in.Metric.Selector
        return nil
}

func Convert_v1_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in *autoscalingv1.PodsMetricStatus, out *autoscaling.PodsMetricStatus, s conversion.Scope) error {
        out.Current = autoscaling.MetricValueStatus{
                AverageValue: &in.CurrentAverageValue,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.Selector,
        }
        return nil
}

func Convert_v1_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in *autoscalingv1.ResourceMetricSource, out *autoscaling.ResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        utilization := in.TargetAverageUtilization
        averageValue := in.TargetAverageValue
        var metricType autoscaling.MetricTargetType
        if utilization == nil {
                metricType = autoscaling.AverageValueMetricType
        } else {
                metricType = autoscaling.UtilizationMetricType
        }
        out.Target = autoscaling.MetricTarget{
                Type:               metricType,
                AverageValue:       averageValue,
                AverageUtilization: utilization,
        }
        return nil
}

func Convert_autoscaling_ResourceMetricSource_To_v1_ResourceMetricSource(in *autoscaling.ResourceMetricSource, out *autoscalingv1.ResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.TargetAverageUtilization = in.Target.AverageUtilization
        out.TargetAverageValue = in.Target.AverageValue
        return nil
}

func Convert_v1_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in *autoscalingv1.ContainerResourceMetricStatus, out *autoscaling.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        out.Container = in.Container
        utilization := in.CurrentAverageUtilization
        averageValue := &in.CurrentAverageValue
        out.Current = autoscaling.MetricValueStatus{
                AverageValue:       averageValue,
                AverageUtilization: utilization,
        }
        return nil
}

func Convert_autoscaling_ContainerResourceMetricStatus_To_v1_ContainerResourceMetricStatus(in *autoscaling.ContainerResourceMetricStatus, out *autoscalingv1.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        out.CurrentAverageUtilization = in.Current.AverageUtilization
        if in.Current.AverageValue != nil {
                out.CurrentAverageValue = *in.Current.AverageValue
        }
        return nil
}

func Convert_v1_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in *autoscalingv1.ResourceMetricStatus, out *autoscaling.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        utilization := in.CurrentAverageUtilization
        averageValue := &in.CurrentAverageValue
        out.Current = autoscaling.MetricValueStatus{
                AverageValue:       averageValue,
                AverageUtilization: utilization,
        }
        return nil
}

func Convert_autoscaling_ResourceMetricStatus_To_v1_ResourceMetricStatus(in *autoscaling.ResourceMetricStatus, out *autoscalingv1.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.CurrentAverageUtilization = in.Current.AverageUtilization
        if in.Current.AverageValue != nil {
                out.CurrentAverageValue = *in.Current.AverageValue
        }
        return nil
}

func Convert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *autoscalingv1.HorizontalPodAutoscaler, s conversion.Scope) error {
        if err := autoConvert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in, out, s); err != nil {
                return err
        }

        // clear any pre-existing round-trip annotations to make sure the only ones set are ones we produced during conversion
        annotations, copiedAnnotations := autoscaling.DropRoundTripHorizontalPodAutoscalerAnnotations(out.Annotations)
        out.Annotations = annotations

        otherMetrics := make([]autoscalingv1.MetricSpec, 0, len(in.Spec.Metrics))
        for _, metric := range in.Spec.Metrics {
                if metric.Type == autoscaling.ResourceMetricSourceType && metric.Resource != nil && metric.Resource.Name == core.ResourceCPU && metric.Resource.Target.AverageUtilization != nil {
                        continue
                }

                convMetric := autoscalingv1.MetricSpec{}
                if err := Convert_autoscaling_MetricSpec_To_v1_MetricSpec(&metric, &convMetric, s); err != nil {
                        return err
                }
                otherMetrics = append(otherMetrics, convMetric)
        }

        // NB: we need to save the status even if it maps to a CPU utilization status in order to save the raw value as well
        currentMetrics := make([]autoscalingv1.MetricStatus, len(in.Status.CurrentMetrics))
        for i, currentMetric := range in.Status.CurrentMetrics {
                if err := Convert_autoscaling_MetricStatus_To_v1_MetricStatus(&currentMetric, &currentMetrics[i], s); err != nil {
                        return err
                }
        }

        // store HPA conditions in an annotation
        currentConditions := make([]autoscalingv1.HorizontalPodAutoscalerCondition, len(in.Status.Conditions))
        for i, currentCondition := range in.Status.Conditions {
                if err := Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v1_HorizontalPodAutoscalerCondition(&currentCondition, &currentConditions[i], s); err != nil {
                        return err
                }
        }

        if len(otherMetrics) > 0 {
                otherMetricsEnc, err := json.Marshal(otherMetrics)
                if err != nil {
                        return err
                }
                // copy before mutating
                if !copiedAnnotations {
                        copiedAnnotations = true
                        out.Annotations = autoscaling.DeepCopyStringMap(out.Annotations)
                }
                out.Annotations[autoscaling.MetricSpecsAnnotation] = string(otherMetricsEnc)
        }

        if len(in.Status.CurrentMetrics) > 0 {
                currentMetricsEnc, err := json.Marshal(currentMetrics)
                if err != nil {
                        return err
                }
                // copy before mutating
                if !copiedAnnotations {
                        copiedAnnotations = true
                        out.Annotations = autoscaling.DeepCopyStringMap(out.Annotations)
                }
                out.Annotations[autoscaling.MetricStatusesAnnotation] = string(currentMetricsEnc)
        }

        if in.Spec.Behavior != nil {
                // TODO: this is marshaling an internal type. Fix this without breaking backwards compatibility.
                behaviorEnc, err := json.Marshal(in.Spec.Behavior)
                if err != nil {
                        return err
                }
                // copy before mutating
                if !copiedAnnotations {
                        copiedAnnotations = true
                        out.Annotations = autoscaling.DeepCopyStringMap(out.Annotations)
                }
                out.Annotations[autoscaling.BehaviorSpecsAnnotation] = string(behaviorEnc)
        }

        if len(in.Status.Conditions) > 0 {
                currentConditionsEnc, err := json.Marshal(currentConditions)
                if err != nil {
                        return err
                }
                // copy before mutating
                if !copiedAnnotations {
                        //nolint:ineffassign
                        copiedAnnotations = true
                        out.Annotations = autoscaling.DeepCopyStringMap(out.Annotations)
                }
                out.Annotations[autoscaling.HorizontalPodAutoscalerConditionsAnnotation] = string(currentConditionsEnc)
        }

        return nil
}

func Convert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *autoscalingv1.HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
        if err := autoConvert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in, out, s); err != nil {
                return err
        }

        if otherMetricsEnc, hasOtherMetrics := out.Annotations[autoscaling.MetricSpecsAnnotation]; hasOtherMetrics {
                var otherMetrics []autoscalingv1.MetricSpec
                if err := json.Unmarshal([]byte(otherMetricsEnc), &otherMetrics); err == nil {
                        // the normal Spec conversion could have populated out.Spec.Metrics with a single element, so deal with that
                        outMetrics := make([]autoscaling.MetricSpec, len(otherMetrics)+len(out.Spec.Metrics))
                        for i, metric := range otherMetrics {
                                if err := Convert_v1_MetricSpec_To_autoscaling_MetricSpec(&metric, &outMetrics[i], s); err != nil {
                                        return err
                                }
                        }
                        if out.Spec.Metrics != nil {
                                outMetrics[len(otherMetrics)] = out.Spec.Metrics[0]
                        }
                        out.Spec.Metrics = outMetrics
                }
        }

        if behaviorEnc, hasConstraints := out.Annotations[autoscaling.BehaviorSpecsAnnotation]; hasConstraints {
                // TODO: this is unmarshaling an internal type. Fix this without breaking backwards compatibility.
                var behavior autoscaling.HorizontalPodAutoscalerBehavior
                if err := json.Unmarshal([]byte(behaviorEnc), &behavior); err == nil && behavior != (autoscaling.HorizontalPodAutoscalerBehavior{}) {
                        out.Spec.Behavior = &behavior
                }
        }

        if currentMetricsEnc, hasCurrentMetrics := out.Annotations[autoscaling.MetricStatusesAnnotation]; hasCurrentMetrics {
                // ignore any existing status values -- the ones here have more information
                var currentMetrics []autoscalingv1.MetricStatus
                if err := json.Unmarshal([]byte(currentMetricsEnc), &currentMetrics); err == nil {
                        out.Status.CurrentMetrics = make([]autoscaling.MetricStatus, len(currentMetrics))
                        for i, currentMetric := range currentMetrics {
                                if err := Convert_v1_MetricStatus_To_autoscaling_MetricStatus(&currentMetric, &out.Status.CurrentMetrics[i], s); err != nil {
                                        return err
                                }
                        }
                }
        }

        // autoscaling/v1 formerly had an implicit default applied in the controller.  In v2beta1, we apply it explicitly.
        // We apply it here, explicitly, since we have access to the full set of metrics from the annotation.
        if len(out.Spec.Metrics) == 0 {
                // no other metrics, no explicit CPU value set
                out.Spec.Metrics = []autoscaling.MetricSpec{
                        {
                                Type: autoscaling.ResourceMetricSourceType,
                                Resource: &autoscaling.ResourceMetricSource{
                                        Name: core.ResourceCPU,
                                        Target: autoscaling.MetricTarget{
                                                Type: autoscaling.UtilizationMetricType,
                                        },
                                },
                        },
                }
                out.Spec.Metrics[0].Resource.Target.AverageUtilization = new(int32)
                *out.Spec.Metrics[0].Resource.Target.AverageUtilization = autoscaling.DefaultCPUUtilization
        }

        if currentConditionsEnc, hasCurrentConditions := out.Annotations[autoscaling.HorizontalPodAutoscalerConditionsAnnotation]; hasCurrentConditions {
                var currentConditions []autoscalingv1.HorizontalPodAutoscalerCondition
                if err := json.Unmarshal([]byte(currentConditionsEnc), &currentConditions); err == nil {
                        out.Status.Conditions = make([]autoscaling.HorizontalPodAutoscalerCondition, len(currentConditions))
                        for i, currentCondition := range currentConditions {
                                if err := Convert_v1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(&currentCondition, &out.Status.Conditions[i], s); err != nil {
                                        return err
                                }
                        }
                }
        }

        // drop round-tripping annotations after converting to internal
        out.Annotations, _ = autoscaling.DropRoundTripHorizontalPodAutoscalerAnnotations(out.Annotations)

        return nil
}

func Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *autoscalingv1.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }

        out.MinReplicas = in.MinReplicas
        out.MaxReplicas = in.MaxReplicas

        for _, metric := range in.Metrics {
                if metric.Type == autoscaling.ResourceMetricSourceType && metric.Resource != nil && metric.Resource.Name == core.ResourceCPU && metric.Resource.Target.AverageUtilization != nil {
                        out.TargetCPUUtilizationPercentage = new(int32)
                        *out.TargetCPUUtilizationPercentage = *metric.Resource.Target.AverageUtilization
                        break
                }
        }

        return nil
}

func Convert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *autoscalingv1.HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }

        out.MinReplicas = in.MinReplicas
        out.MaxReplicas = in.MaxReplicas

        if in.TargetCPUUtilizationPercentage != nil {
                out.Metrics = []autoscaling.MetricSpec{
                        {
                                Type: autoscaling.ResourceMetricSourceType,
                                Resource: &autoscaling.ResourceMetricSource{
                                        Name: core.ResourceCPU,
                                        Target: autoscaling.MetricTarget{
                                                Type: autoscaling.UtilizationMetricType,
                                        },
                                },
                        },
                }
                out.Metrics[0].Resource.Target.AverageUtilization = new(int32)
                *out.Metrics[0].Resource.Target.AverageUtilization = *in.TargetCPUUtilizationPercentage
        }

        return nil
}

func Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *autoscalingv1.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.LastScaleTime = in.LastScaleTime

        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas

        for _, metric := range in.CurrentMetrics {
                if metric.Type == autoscaling.ResourceMetricSourceType && metric.Resource != nil && metric.Resource.Name == core.ResourceCPU {
                        if metric.Resource.Current.AverageUtilization != nil {

                                out.CurrentCPUUtilizationPercentage = new(int32)
                                *out.CurrentCPUUtilizationPercentage = *metric.Resource.Current.AverageUtilization
                        }
                }
        }
        return nil
}

func Convert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *autoscalingv1.HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.LastScaleTime = in.LastScaleTime

        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas

        if in.CurrentCPUUtilizationPercentage != nil {
                out.CurrentMetrics = []autoscaling.MetricStatus{
                        {
                                Type: autoscaling.ResourceMetricSourceType,
                                Resource: &autoscaling.ResourceMetricStatus{
                                        Name: core.ResourceCPU,
                                },
                        },
                }
                out.CurrentMetrics[0].Resource.Current.AverageUtilization = new(int32)
                *out.CurrentMetrics[0].Resource.Current.AverageUtilization = *in.CurrentCPUUtilizationPercentage
        }
        return nil
}

func Convert_v1_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in *autoscalingv1.ContainerResourceMetricSource, out *autoscaling.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        out.Container = in.Container
        utilization := in.TargetAverageUtilization
        averageValue := in.TargetAverageValue
        var metricType autoscaling.MetricTargetType
        if utilization == nil {
                metricType = autoscaling.AverageValueMetricType
        } else {
                metricType = autoscaling.UtilizationMetricType
        }
        out.Target = autoscaling.MetricTarget{
                Type:               metricType,
                AverageValue:       averageValue,
                AverageUtilization: utilization,
        }
        return nil
}

func Convert_autoscaling_ContainerResourceMetricSource_To_v1_ContainerResourceMetricSource(in *autoscaling.ContainerResourceMetricSource, out *autoscalingv1.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        out.TargetAverageUtilization = in.Target.AverageUtilization
        out.TargetAverageValue = in.Target.AverageValue
        return nil
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1

import (
        autoscalingv1 "k8s.io/api/autoscaling/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/utils/ptr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_HorizontalPodAutoscaler(obj *autoscalingv1.HorizontalPodAutoscaler) {
        if obj.Spec.MinReplicas == nil {
                obj.Spec.MinReplicas = ptr.To[int32](1)
        }

        // NB: we apply a default for CPU utilization in conversion because
        // we need access to the annotations to properly apply the default.
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1

import (
        autoscalingv1 "k8s.io/api/autoscaling/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "autoscaling"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &autoscalingv1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        autoscalingv1 "k8s.io/api/autoscaling/v1"
        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*autoscalingv1.CrossVersionObjectReference)(nil), (*autoscaling.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(a.(*autoscalingv1.CrossVersionObjectReference), b.(*autoscaling.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.CrossVersionObjectReference)(nil), (*autoscalingv1.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(a.(*autoscaling.CrossVersionObjectReference), b.(*autoscalingv1.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv1.HorizontalPodAutoscalerCondition)(nil), (*autoscaling.HorizontalPodAutoscalerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(a.(*autoscalingv1.HorizontalPodAutoscalerCondition), b.(*autoscaling.HorizontalPodAutoscalerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerCondition)(nil), (*autoscalingv1.HorizontalPodAutoscalerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v1_HorizontalPodAutoscalerCondition(a.(*autoscaling.HorizontalPodAutoscalerCondition), b.(*autoscalingv1.HorizontalPodAutoscalerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv1.HorizontalPodAutoscalerList)(nil), (*autoscaling.HorizontalPodAutoscalerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(a.(*autoscalingv1.HorizontalPodAutoscalerList), b.(*autoscaling.HorizontalPodAutoscalerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerList)(nil), (*autoscalingv1.HorizontalPodAutoscalerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(a.(*autoscaling.HorizontalPodAutoscalerList), b.(*autoscalingv1.HorizontalPodAutoscalerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv1.MetricSpec)(nil), (*autoscaling.MetricSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_MetricSpec_To_autoscaling_MetricSpec(a.(*autoscalingv1.MetricSpec), b.(*autoscaling.MetricSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricSpec)(nil), (*autoscalingv1.MetricSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricSpec_To_v1_MetricSpec(a.(*autoscaling.MetricSpec), b.(*autoscalingv1.MetricSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv1.MetricStatus)(nil), (*autoscaling.MetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_MetricStatus_To_autoscaling_MetricStatus(a.(*autoscalingv1.MetricStatus), b.(*autoscaling.MetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricStatus)(nil), (*autoscalingv1.MetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricStatus_To_v1_MetricStatus(a.(*autoscaling.MetricStatus), b.(*autoscalingv1.MetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv1.Scale)(nil), (*autoscaling.Scale)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Scale_To_autoscaling_Scale(a.(*autoscalingv1.Scale), b.(*autoscaling.Scale), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.Scale)(nil), (*autoscalingv1.Scale)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_Scale_To_v1_Scale(a.(*autoscaling.Scale), b.(*autoscalingv1.Scale), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv1.ScaleSpec)(nil), (*autoscaling.ScaleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec(a.(*autoscalingv1.ScaleSpec), b.(*autoscaling.ScaleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ScaleSpec)(nil), (*autoscalingv1.ScaleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec(a.(*autoscaling.ScaleSpec), b.(*autoscalingv1.ScaleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv1.ScaleStatus)(nil), (*autoscaling.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus(a.(*autoscalingv1.ScaleStatus), b.(*autoscaling.ScaleStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ScaleStatus)(nil), (*autoscalingv1.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus(a.(*autoscaling.ScaleStatus), b.(*autoscalingv1.ScaleStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ContainerResourceMetricSource)(nil), (*autoscalingv1.ContainerResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ContainerResourceMetricSource_To_v1_ContainerResourceMetricSource(a.(*autoscaling.ContainerResourceMetricSource), b.(*autoscalingv1.ContainerResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ContainerResourceMetricStatus)(nil), (*autoscalingv1.ContainerResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ContainerResourceMetricStatus_To_v1_ContainerResourceMetricStatus(a.(*autoscaling.ContainerResourceMetricStatus), b.(*autoscalingv1.ContainerResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ExternalMetricSource)(nil), (*autoscalingv1.ExternalMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ExternalMetricSource_To_v1_ExternalMetricSource(a.(*autoscaling.ExternalMetricSource), b.(*autoscalingv1.ExternalMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ExternalMetricStatus)(nil), (*autoscalingv1.ExternalMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ExternalMetricStatus_To_v1_ExternalMetricStatus(a.(*autoscaling.ExternalMetricStatus), b.(*autoscalingv1.ExternalMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.HorizontalPodAutoscalerSpec)(nil), (*autoscalingv1.HorizontalPodAutoscalerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(a.(*autoscaling.HorizontalPodAutoscalerSpec), b.(*autoscalingv1.HorizontalPodAutoscalerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.HorizontalPodAutoscalerStatus)(nil), (*autoscalingv1.HorizontalPodAutoscalerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(a.(*autoscaling.HorizontalPodAutoscalerStatus), b.(*autoscalingv1.HorizontalPodAutoscalerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.HorizontalPodAutoscaler)(nil), (*autoscalingv1.HorizontalPodAutoscaler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(a.(*autoscaling.HorizontalPodAutoscaler), b.(*autoscalingv1.HorizontalPodAutoscaler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.MetricTarget)(nil), (*autoscalingv1.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricTarget_To_v1_CrossVersionObjectReference(a.(*autoscaling.MetricTarget), b.(*autoscalingv1.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ObjectMetricSource)(nil), (*autoscalingv1.ObjectMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ObjectMetricSource_To_v1_ObjectMetricSource(a.(*autoscaling.ObjectMetricSource), b.(*autoscalingv1.ObjectMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ObjectMetricStatus)(nil), (*autoscalingv1.ObjectMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ObjectMetricStatus_To_v1_ObjectMetricStatus(a.(*autoscaling.ObjectMetricStatus), b.(*autoscalingv1.ObjectMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.PodsMetricSource)(nil), (*autoscalingv1.PodsMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_PodsMetricSource_To_v1_PodsMetricSource(a.(*autoscaling.PodsMetricSource), b.(*autoscalingv1.PodsMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.PodsMetricStatus)(nil), (*autoscalingv1.PodsMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_PodsMetricStatus_To_v1_PodsMetricStatus(a.(*autoscaling.PodsMetricStatus), b.(*autoscalingv1.PodsMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ResourceMetricSource)(nil), (*autoscalingv1.ResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ResourceMetricSource_To_v1_ResourceMetricSource(a.(*autoscaling.ResourceMetricSource), b.(*autoscalingv1.ResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ResourceMetricStatus)(nil), (*autoscalingv1.ResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ResourceMetricStatus_To_v1_ResourceMetricStatus(a.(*autoscaling.ResourceMetricStatus), b.(*autoscalingv1.ResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.ContainerResourceMetricSource)(nil), (*autoscaling.ContainerResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(a.(*autoscalingv1.ContainerResourceMetricSource), b.(*autoscaling.ContainerResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.ContainerResourceMetricStatus)(nil), (*autoscaling.ContainerResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(a.(*autoscalingv1.ContainerResourceMetricStatus), b.(*autoscaling.ContainerResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.CrossVersionObjectReference)(nil), (*autoscaling.MetricTarget)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CrossVersionObjectReference_To_autoscaling_MetricTarget(a.(*autoscalingv1.CrossVersionObjectReference), b.(*autoscaling.MetricTarget), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.ExternalMetricSource)(nil), (*autoscaling.ExternalMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ExternalMetricSource_To_autoscaling_ExternalMetricSource(a.(*autoscalingv1.ExternalMetricSource), b.(*autoscaling.ExternalMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.ExternalMetricStatus)(nil), (*autoscaling.ExternalMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(a.(*autoscalingv1.ExternalMetricStatus), b.(*autoscaling.ExternalMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.HorizontalPodAutoscalerSpec)(nil), (*autoscaling.HorizontalPodAutoscalerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(a.(*autoscalingv1.HorizontalPodAutoscalerSpec), b.(*autoscaling.HorizontalPodAutoscalerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.HorizontalPodAutoscalerStatus)(nil), (*autoscaling.HorizontalPodAutoscalerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(a.(*autoscalingv1.HorizontalPodAutoscalerStatus), b.(*autoscaling.HorizontalPodAutoscalerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.HorizontalPodAutoscaler)(nil), (*autoscaling.HorizontalPodAutoscaler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(a.(*autoscalingv1.HorizontalPodAutoscaler), b.(*autoscaling.HorizontalPodAutoscaler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.ObjectMetricSource)(nil), (*autoscaling.ObjectMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ObjectMetricSource_To_autoscaling_ObjectMetricSource(a.(*autoscalingv1.ObjectMetricSource), b.(*autoscaling.ObjectMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.ObjectMetricStatus)(nil), (*autoscaling.ObjectMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(a.(*autoscalingv1.ObjectMetricStatus), b.(*autoscaling.ObjectMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.PodsMetricSource)(nil), (*autoscaling.PodsMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodsMetricSource_To_autoscaling_PodsMetricSource(a.(*autoscalingv1.PodsMetricSource), b.(*autoscaling.PodsMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.PodsMetricStatus)(nil), (*autoscaling.PodsMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodsMetricStatus_To_autoscaling_PodsMetricStatus(a.(*autoscalingv1.PodsMetricStatus), b.(*autoscaling.PodsMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.ResourceMetricSource)(nil), (*autoscaling.ResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceMetricSource_To_autoscaling_ResourceMetricSource(a.(*autoscalingv1.ResourceMetricSource), b.(*autoscaling.ResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv1.ResourceMetricStatus)(nil), (*autoscaling.ResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(a.(*autoscalingv1.ResourceMetricStatus), b.(*autoscaling.ResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in *autoscalingv1.ContainerResourceMetricSource, out *autoscaling.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        // WARNING: in.TargetAverageUtilization requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetAverageValue requires manual conversion: does not exist in peer-type
        out.Container = in.Container
        return nil
}

func autoConvert_autoscaling_ContainerResourceMetricSource_To_v1_ContainerResourceMetricSource(in *autoscaling.ContainerResourceMetricSource, out *autoscalingv1.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = corev1.ResourceName(in.Name)
        out.Container = in.Container
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in *autoscalingv1.ContainerResourceMetricStatus, out *autoscaling.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        // WARNING: in.CurrentAverageUtilization requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentAverageValue requires manual conversion: does not exist in peer-type
        out.Container = in.Container
        return nil
}

func autoConvert_autoscaling_ContainerResourceMetricStatus_To_v1_ContainerResourceMetricStatus(in *autoscaling.ContainerResourceMetricStatus, out *autoscalingv1.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = corev1.ResourceName(in.Name)
        out.Container = in.Container
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *autoscalingv1.CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Name = in.Name
        out.APIVersion = in.APIVersion
        return nil
}

// Convert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference is an autogenerated conversion function.
func Convert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *autoscalingv1.CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
        return autoConvert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in, out, s)
}

func autoConvert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *autoscalingv1.CrossVersionObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Name = in.Name
        out.APIVersion = in.APIVersion
        return nil
}

// Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference is an autogenerated conversion function.
func Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *autoscalingv1.CrossVersionObjectReference, s conversion.Scope) error {
        return autoConvert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(in, out, s)
}

func autoConvert_v1_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in *autoscalingv1.ExternalMetricSource, out *autoscaling.ExternalMetricSource, s conversion.Scope) error {
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.MetricSelector requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetValue requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetAverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ExternalMetricSource_To_v1_ExternalMetricSource(in *autoscaling.ExternalMetricSource, out *autoscalingv1.ExternalMetricSource, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in *autoscalingv1.ExternalMetricStatus, out *autoscaling.ExternalMetricStatus, s conversion.Scope) error {
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.MetricSelector requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentValue requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentAverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ExternalMetricStatus_To_v1_ExternalMetricStatus(in *autoscaling.ExternalMetricStatus, out *autoscalingv1.ExternalMetricStatus, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *autoscalingv1.HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *autoscalingv1.HorizontalPodAutoscaler, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in *autoscalingv1.HorizontalPodAutoscalerCondition, out *autoscaling.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        out.Type = autoscaling.HorizontalPodAutoscalerConditionType(in.Type)
        out.Status = autoscaling.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition is an autogenerated conversion function.
func Convert_v1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in *autoscalingv1.HorizontalPodAutoscalerCondition, out *autoscaling.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        return autoConvert_v1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerCondition_To_v1_HorizontalPodAutoscalerCondition(in *autoscaling.HorizontalPodAutoscalerCondition, out *autoscalingv1.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        out.Type = autoscalingv1.HorizontalPodAutoscalerConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v1_HorizontalPodAutoscalerCondition is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v1_HorizontalPodAutoscalerCondition(in *autoscaling.HorizontalPodAutoscalerCondition, out *autoscalingv1.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerCondition_To_v1_HorizontalPodAutoscalerCondition(in, out, s)
}

func autoConvert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *autoscalingv1.HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]autoscaling.HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        if err := Convert_v1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList is an autogenerated conversion function.
func Convert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *autoscalingv1.HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
        return autoConvert_v1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *autoscalingv1.HorizontalPodAutoscalerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]autoscalingv1.HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_HorizontalPodAutoscaler_To_v1_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *autoscalingv1.HorizontalPodAutoscalerList, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v1_HorizontalPodAutoscalerList(in, out, s)
}

func autoConvert_v1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *autoscalingv1.HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_v1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }
        out.MinReplicas = (*int32)(unsafe.Pointer(in.MinReplicas))
        out.MaxReplicas = in.MaxReplicas
        // WARNING: in.TargetCPUUtilizationPercentage requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v1_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *autoscalingv1.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v1_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }
        out.MinReplicas = (*int32)(unsafe.Pointer(in.MinReplicas))
        out.MaxReplicas = in.MaxReplicas
        // WARNING: in.Metrics requires manual conversion: does not exist in peer-type
        // WARNING: in.Behavior requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *autoscalingv1.HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.LastScaleTime = (*metav1.Time)(unsafe.Pointer(in.LastScaleTime))
        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas
        // WARNING: in.CurrentCPUUtilizationPercentage requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v1_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *autoscalingv1.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.LastScaleTime = (*metav1.Time)(unsafe.Pointer(in.LastScaleTime))
        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas
        // WARNING: in.CurrentMetrics requires manual conversion: does not exist in peer-type
        // WARNING: in.Conditions requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_MetricSpec_To_autoscaling_MetricSpec(in *autoscalingv1.MetricSpec, out *autoscaling.MetricSpec, s conversion.Scope) error {
        out.Type = autoscaling.MetricSourceType(in.Type)
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(autoscaling.ObjectMetricSource)
                if err := Convert_v1_ObjectMetricSource_To_autoscaling_ObjectMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Object = nil
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(autoscaling.PodsMetricSource)
                if err := Convert_v1_PodsMetricSource_To_autoscaling_PodsMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Pods = nil
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(autoscaling.ResourceMetricSource)
                if err := Convert_v1_ResourceMetricSource_To_autoscaling_ResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Resource = nil
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscaling.ContainerResourceMetricSource)
                if err := Convert_v1_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(autoscaling.ExternalMetricSource)
                if err := Convert_v1_ExternalMetricSource_To_autoscaling_ExternalMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.External = nil
        }
        return nil
}

// Convert_v1_MetricSpec_To_autoscaling_MetricSpec is an autogenerated conversion function.
func Convert_v1_MetricSpec_To_autoscaling_MetricSpec(in *autoscalingv1.MetricSpec, out *autoscaling.MetricSpec, s conversion.Scope) error {
        return autoConvert_v1_MetricSpec_To_autoscaling_MetricSpec(in, out, s)
}

func autoConvert_autoscaling_MetricSpec_To_v1_MetricSpec(in *autoscaling.MetricSpec, out *autoscalingv1.MetricSpec, s conversion.Scope) error {
        out.Type = autoscalingv1.MetricSourceType(in.Type)
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(autoscalingv1.ObjectMetricSource)
                if err := Convert_autoscaling_ObjectMetricSource_To_v1_ObjectMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Object = nil
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(autoscalingv1.PodsMetricSource)
                if err := Convert_autoscaling_PodsMetricSource_To_v1_PodsMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Pods = nil
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(autoscalingv1.ResourceMetricSource)
                if err := Convert_autoscaling_ResourceMetricSource_To_v1_ResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Resource = nil
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscalingv1.ContainerResourceMetricSource)
                if err := Convert_autoscaling_ContainerResourceMetricSource_To_v1_ContainerResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(autoscalingv1.ExternalMetricSource)
                if err := Convert_autoscaling_ExternalMetricSource_To_v1_ExternalMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.External = nil
        }
        return nil
}

// Convert_autoscaling_MetricSpec_To_v1_MetricSpec is an autogenerated conversion function.
func Convert_autoscaling_MetricSpec_To_v1_MetricSpec(in *autoscaling.MetricSpec, out *autoscalingv1.MetricSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricSpec_To_v1_MetricSpec(in, out, s)
}

func autoConvert_v1_MetricStatus_To_autoscaling_MetricStatus(in *autoscalingv1.MetricStatus, out *autoscaling.MetricStatus, s conversion.Scope) error {
        out.Type = autoscaling.MetricSourceType(in.Type)
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(autoscaling.ObjectMetricStatus)
                if err := Convert_v1_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Object = nil
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(autoscaling.PodsMetricStatus)
                if err := Convert_v1_PodsMetricStatus_To_autoscaling_PodsMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Pods = nil
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(autoscaling.ResourceMetricStatus)
                if err := Convert_v1_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Resource = nil
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscaling.ContainerResourceMetricStatus)
                if err := Convert_v1_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(autoscaling.ExternalMetricStatus)
                if err := Convert_v1_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.External = nil
        }
        return nil
}

// Convert_v1_MetricStatus_To_autoscaling_MetricStatus is an autogenerated conversion function.
func Convert_v1_MetricStatus_To_autoscaling_MetricStatus(in *autoscalingv1.MetricStatus, out *autoscaling.MetricStatus, s conversion.Scope) error {
        return autoConvert_v1_MetricStatus_To_autoscaling_MetricStatus(in, out, s)
}

func autoConvert_autoscaling_MetricStatus_To_v1_MetricStatus(in *autoscaling.MetricStatus, out *autoscalingv1.MetricStatus, s conversion.Scope) error {
        out.Type = autoscalingv1.MetricSourceType(in.Type)
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(autoscalingv1.ObjectMetricStatus)
                if err := Convert_autoscaling_ObjectMetricStatus_To_v1_ObjectMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Object = nil
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(autoscalingv1.PodsMetricStatus)
                if err := Convert_autoscaling_PodsMetricStatus_To_v1_PodsMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Pods = nil
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(autoscalingv1.ResourceMetricStatus)
                if err := Convert_autoscaling_ResourceMetricStatus_To_v1_ResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Resource = nil
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscalingv1.ContainerResourceMetricStatus)
                if err := Convert_autoscaling_ContainerResourceMetricStatus_To_v1_ContainerResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(autoscalingv1.ExternalMetricStatus)
                if err := Convert_autoscaling_ExternalMetricStatus_To_v1_ExternalMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.External = nil
        }
        return nil
}

// Convert_autoscaling_MetricStatus_To_v1_MetricStatus is an autogenerated conversion function.
func Convert_autoscaling_MetricStatus_To_v1_MetricStatus(in *autoscaling.MetricStatus, out *autoscalingv1.MetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricStatus_To_v1_MetricStatus(in, out, s)
}

func autoConvert_v1_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in *autoscalingv1.ObjectMetricSource, out *autoscaling.ObjectMetricSource, s conversion.Scope) error {
        if err := Convert_v1_CrossVersionObjectReference_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetValue requires manual conversion: does not exist in peer-type
        // WARNING: in.Selector requires manual conversion: does not exist in peer-type
        // WARNING: in.AverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ObjectMetricSource_To_v1_ObjectMetricSource(in *autoscaling.ObjectMetricSource, out *autoscalingv1.ObjectMetricSource, s conversion.Scope) error {
        // WARNING: in.DescribedObject requires manual conversion: does not exist in peer-type
        if err := Convert_autoscaling_MetricTarget_To_v1_CrossVersionObjectReference(&in.Target, &out.Target, s); err != nil {
                return err
        }
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in *autoscalingv1.ObjectMetricStatus, out *autoscaling.ObjectMetricStatus, s conversion.Scope) error {
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentValue requires manual conversion: does not exist in peer-type
        // WARNING: in.Selector requires manual conversion: does not exist in peer-type
        // WARNING: in.AverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ObjectMetricStatus_To_v1_ObjectMetricStatus(in *autoscaling.ObjectMetricStatus, out *autoscalingv1.ObjectMetricStatus, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        // WARNING: in.DescribedObject requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_PodsMetricSource_To_autoscaling_PodsMetricSource(in *autoscalingv1.PodsMetricSource, out *autoscaling.PodsMetricSource, s conversion.Scope) error {
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetAverageValue requires manual conversion: does not exist in peer-type
        // WARNING: in.Selector requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_PodsMetricSource_To_v1_PodsMetricSource(in *autoscaling.PodsMetricSource, out *autoscalingv1.PodsMetricSource, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in *autoscalingv1.PodsMetricStatus, out *autoscaling.PodsMetricStatus, s conversion.Scope) error {
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentAverageValue requires manual conversion: does not exist in peer-type
        // WARNING: in.Selector requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_PodsMetricStatus_To_v1_PodsMetricStatus(in *autoscaling.PodsMetricStatus, out *autoscalingv1.PodsMetricStatus, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in *autoscalingv1.ResourceMetricSource, out *autoscaling.ResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        // WARNING: in.TargetAverageUtilization requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetAverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ResourceMetricSource_To_v1_ResourceMetricSource(in *autoscaling.ResourceMetricSource, out *autoscalingv1.ResourceMetricSource, s conversion.Scope) error {
        out.Name = corev1.ResourceName(in.Name)
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in *autoscalingv1.ResourceMetricStatus, out *autoscaling.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        // WARNING: in.CurrentAverageUtilization requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentAverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ResourceMetricStatus_To_v1_ResourceMetricStatus(in *autoscaling.ResourceMetricStatus, out *autoscalingv1.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = corev1.ResourceName(in.Name)
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v1_Scale_To_autoscaling_Scale(in *autoscalingv1.Scale, out *autoscaling.Scale, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_Scale_To_autoscaling_Scale is an autogenerated conversion function.
func Convert_v1_Scale_To_autoscaling_Scale(in *autoscalingv1.Scale, out *autoscaling.Scale, s conversion.Scope) error {
        return autoConvert_v1_Scale_To_autoscaling_Scale(in, out, s)
}

func autoConvert_autoscaling_Scale_To_v1_Scale(in *autoscaling.Scale, out *autoscalingv1.Scale, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_Scale_To_v1_Scale is an autogenerated conversion function.
func Convert_autoscaling_Scale_To_v1_Scale(in *autoscaling.Scale, out *autoscalingv1.Scale, s conversion.Scope) error {
        return autoConvert_autoscaling_Scale_To_v1_Scale(in, out, s)
}

func autoConvert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in *autoscalingv1.ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
        out.Replicas = in.Replicas
        return nil
}

// Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec is an autogenerated conversion function.
func Convert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in *autoscalingv1.ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
        return autoConvert_v1_ScaleSpec_To_autoscaling_ScaleSpec(in, out, s)
}

func autoConvert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in *autoscaling.ScaleSpec, out *autoscalingv1.ScaleSpec, s conversion.Scope) error {
        out.Replicas = in.Replicas
        return nil
}

// Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec is an autogenerated conversion function.
func Convert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in *autoscaling.ScaleSpec, out *autoscalingv1.ScaleSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_ScaleSpec_To_v1_ScaleSpec(in, out, s)
}

func autoConvert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in *autoscalingv1.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.Selector = in.Selector
        return nil
}

// Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus is an autogenerated conversion function.
func Convert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in *autoscalingv1.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
        return autoConvert_v1_ScaleStatus_To_autoscaling_ScaleStatus(in, out, s)
}

func autoConvert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in *autoscaling.ScaleStatus, out *autoscalingv1.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.Selector = in.Selector
        return nil
}

// Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus is an autogenerated conversion function.
func Convert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in *autoscaling.ScaleStatus, out *autoscalingv1.ScaleStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ScaleStatus_To_v1_ScaleStatus(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        autoscalingv1 "k8s.io/api/autoscaling/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&autoscalingv1.HorizontalPodAutoscaler{}, func(obj interface{}) {
                SetObjectDefaults_HorizontalPodAutoscaler(obj.(*autoscalingv1.HorizontalPodAutoscaler))
        })
        scheme.AddTypeDefaultingFunc(&autoscalingv1.HorizontalPodAutoscalerList{}, func(obj interface{}) {
                SetObjectDefaults_HorizontalPodAutoscalerList(obj.(*autoscalingv1.HorizontalPodAutoscalerList))
        })
        return nil
}

func SetObjectDefaults_HorizontalPodAutoscaler(in *autoscalingv1.HorizontalPodAutoscaler) {
        SetDefaults_HorizontalPodAutoscaler(in)
}

func SetObjectDefaults_HorizontalPodAutoscalerList(in *autoscalingv1.HorizontalPodAutoscalerList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_HorizontalPodAutoscaler(a)
        }
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 validation-gen. DO NOT EDIT.

package v1

import (
        context "context"
        fmt "fmt"

        autoscalingv1 "k8s.io/api/autoscaling/v1"
        operation "k8s.io/apimachinery/pkg/api/operation"
        safe "k8s.io/apimachinery/pkg/api/safe"
        validate "k8s.io/apimachinery/pkg/api/validate"
        runtime "k8s.io/apimachinery/pkg/runtime"
        field "k8s.io/apimachinery/pkg/util/validation/field"
)

func init() { localSchemeBuilder.Register(RegisterValidations) }

// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
        scheme.AddValidationFunc((*autoscalingv1.Scale)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/scale":
                        return Validate_Scale(ctx, op, nil /* fldPath */, obj.(*autoscalingv1.Scale), safe.Cast[*autoscalingv1.Scale](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        return nil
}

func Validate_Scale(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *autoscalingv1.Scale) (errs field.ErrorList) {
        // field autoscalingv1.Scale.TypeMeta has no validation
        // field autoscalingv1.Scale.ObjectMeta has no validation

        // field autoscalingv1.Scale.Spec
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *autoscalingv1.ScaleSpec) (errs field.ErrorList) {
                        errs = append(errs, Validate_ScaleSpec(ctx, op, fldPath, obj, oldObj)...)
                        return
                }(fldPath.Child("spec"), &obj.Spec, safe.Field(oldObj, func(oldObj *autoscalingv1.Scale) *autoscalingv1.ScaleSpec { return &oldObj.Spec }))...)

        // field autoscalingv1.Scale.Status has no validation
        return errs
}

func Validate_ScaleSpec(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *autoscalingv1.ScaleSpec) (errs field.ErrorList) {
        // field autoscalingv1.ScaleSpec.Replicas
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *int32) (errs field.ErrorList) {
                        // optional value-type fields with zero-value defaults are purely documentation
                        if op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
                                return nil // no changes
                        }
                        errs = append(errs, validate.Minimum(ctx, op, fldPath, obj, oldObj, 0)...)
                        return
                }(fldPath.Child("replicas"), &obj.Replicas, safe.Field(oldObj, func(oldObj *autoscalingv1.ScaleSpec) *int32 { return &oldObj.Replicas }))...)

        return errs
}

/*
Copyright 2021 The Kubernetes Authors.

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.
*/

package v2

import (
        autoscalingv2 "k8s.io/api/autoscaling/v2"

        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
)

func Convert_autoscaling_HorizontalPodAutoscaler_To_v2_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *autoscalingv2.HorizontalPodAutoscaler, s conversion.Scope) error {
        if err := autoConvert_autoscaling_HorizontalPodAutoscaler_To_v2_HorizontalPodAutoscaler(in, out, s); err != nil {
                return err
        }
        // v2 round-trips to internal without any serialized annotations, make sure any from other versions don't get serialized
        out.Annotations, _ = autoscaling.DropRoundTripHorizontalPodAutoscalerAnnotations(out.Annotations)
        return nil
}

func Convert_v2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *autoscalingv2.HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
        if err := autoConvert_v2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in, out, s); err != nil {
                return err
        }
        // v2 round-trips to internal without any serialized annotations, make sure any from other versions don't get serialized
        out.Annotations, _ = autoscaling.DropRoundTripHorizontalPodAutoscalerAnnotations(out.Annotations)
        return nil
}

/*
Copyright 2021 The Kubernetes Authors.

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.
*/

package v2

import (
        autoscalingv2 "k8s.io/api/autoscaling/v2"
        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/utils/ptr"
)

var (
        // These constants repeats previous HPA behavior
        scaleUpLimitPercent         int32 = 100
        scaleUpLimitMinimumPods     int32 = 4
        scaleUpPeriod               int32 = 15
        scaleUpStabilizationSeconds int32
        maxPolicy                   = autoscalingv2.MaxChangePolicySelect
        defaultHPAScaleUpRules      = autoscalingv2.HPAScalingRules{
                StabilizationWindowSeconds: &scaleUpStabilizationSeconds,
                SelectPolicy:               &maxPolicy,
                Policies: []autoscalingv2.HPAScalingPolicy{
                        {
                                Type:          autoscalingv2.PodsScalingPolicy,
                                Value:         scaleUpLimitMinimumPods,
                                PeriodSeconds: scaleUpPeriod,
                        },
                        {
                                Type:          autoscalingv2.PercentScalingPolicy,
                                Value:         scaleUpLimitPercent,
                                PeriodSeconds: scaleUpPeriod,
                        },
                },
        }
        scaleDownPeriod int32 = 15
        // Currently we can set the downscaleStabilizationWindow from the command line
        // So we can not rewrite the command line option from here
        scaleDownLimitPercent    int32 = 100
        defaultHPAScaleDownRules       = autoscalingv2.HPAScalingRules{
                StabilizationWindowSeconds: nil,
                SelectPolicy:               &maxPolicy,
                Policies: []autoscalingv2.HPAScalingPolicy{
                        {
                                Type:          autoscalingv2.PercentScalingPolicy,
                                Value:         scaleDownLimitPercent,
                                PeriodSeconds: scaleDownPeriod,
                        },
                },
        }
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_HorizontalPodAutoscaler(obj *autoscalingv2.HorizontalPodAutoscaler) {
        if obj.Spec.MinReplicas == nil {
                obj.Spec.MinReplicas = ptr.To[int32](1)
        }

        if len(obj.Spec.Metrics) == 0 {
                utilizationDefaultVal := int32(autoscaling.DefaultCPUUtilization)
                obj.Spec.Metrics = []autoscalingv2.MetricSpec{
                        {
                                Type: autoscalingv2.ResourceMetricSourceType,
                                Resource: &autoscalingv2.ResourceMetricSource{
                                        Name: v1.ResourceCPU,
                                        Target: autoscalingv2.MetricTarget{
                                                Type:               autoscalingv2.UtilizationMetricType,
                                                AverageUtilization: &utilizationDefaultVal,
                                        },
                                },
                        },
                }
        }
        SetDefaults_HorizontalPodAutoscalerBehavior(obj)
}

// SetDefaults_HorizontalPodAutoscalerBehavior fills the behavior if it contains
// at least one scaling rule policy (for scale-up or scale-down)
func SetDefaults_HorizontalPodAutoscalerBehavior(obj *autoscalingv2.HorizontalPodAutoscaler) {
        // If behavior contains a scaling rule policy (either for scale-up, scale-down, or both), we
        // should fill all the unset scaling policy fields (i.e. StabilizationWindowSeconds,
        // SelectPolicy, Policies) with default values
        if obj.Spec.Behavior != nil {
                obj.Spec.Behavior.ScaleUp = GenerateHPAScaleUpRules(obj.Spec.Behavior.ScaleUp)
                obj.Spec.Behavior.ScaleDown = GenerateHPAScaleDownRules(obj.Spec.Behavior.ScaleDown)
        }
}

// GenerateHPAScaleUpRules returns a fully-initialized HPAScalingRules value
// We guarantee that no pointer in the structure will have the 'nil' value
func GenerateHPAScaleUpRules(scalingRules *autoscalingv2.HPAScalingRules) *autoscalingv2.HPAScalingRules {
        defaultScalingRules := defaultHPAScaleUpRules.DeepCopy()
        return copyHPAScalingRules(scalingRules, defaultScalingRules)
}

// GenerateHPAScaleDownRules returns a fully-initialized HPAScalingRules value
// We guarantee that no pointer in the structure will have the 'nil' value
// EXCEPT StabilizationWindowSeconds, for reasoning check the comment for defaultHPAScaleDownRules
func GenerateHPAScaleDownRules(scalingRules *autoscalingv2.HPAScalingRules) *autoscalingv2.HPAScalingRules {
        defaultScalingRules := defaultHPAScaleDownRules.DeepCopy()
        return copyHPAScalingRules(scalingRules, defaultScalingRules)
}

// copyHPAScalingRules copies all non-`nil` fields in HPA constraint structure
func copyHPAScalingRules(from, to *autoscalingv2.HPAScalingRules) *autoscalingv2.HPAScalingRules {
        if from == nil {
                return to
        }
        if from.SelectPolicy != nil {
                to.SelectPolicy = from.SelectPolicy
        }
        if from.StabilizationWindowSeconds != nil {
                to.StabilizationWindowSeconds = from.StabilizationWindowSeconds
        }
        if from.Policies != nil {
                to.Policies = from.Policies
        }
        if from.Tolerance != nil {
                to.Tolerance = from.Tolerance
        }
        return to
}

/*
Copyright 2021 The Kubernetes Authors.

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.
*/

package v2

import (
        autoscalingv2 "k8s.io/api/autoscaling/v2"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "autoscaling"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v2"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &autoscalingv2.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v2

import (
        unsafe "unsafe"

        autoscalingv2 "k8s.io/api/autoscaling/v2"
        v1 "k8s.io/api/core/v1"
        resource "k8s.io/apimachinery/pkg/api/resource"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.ContainerResourceMetricSource)(nil), (*autoscaling.ContainerResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(a.(*autoscalingv2.ContainerResourceMetricSource), b.(*autoscaling.ContainerResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ContainerResourceMetricSource)(nil), (*autoscalingv2.ContainerResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ContainerResourceMetricSource_To_v2_ContainerResourceMetricSource(a.(*autoscaling.ContainerResourceMetricSource), b.(*autoscalingv2.ContainerResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.ContainerResourceMetricStatus)(nil), (*autoscaling.ContainerResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(a.(*autoscalingv2.ContainerResourceMetricStatus), b.(*autoscaling.ContainerResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ContainerResourceMetricStatus)(nil), (*autoscalingv2.ContainerResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ContainerResourceMetricStatus_To_v2_ContainerResourceMetricStatus(a.(*autoscaling.ContainerResourceMetricStatus), b.(*autoscalingv2.ContainerResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.CrossVersionObjectReference)(nil), (*autoscaling.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(a.(*autoscalingv2.CrossVersionObjectReference), b.(*autoscaling.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.CrossVersionObjectReference)(nil), (*autoscalingv2.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_CrossVersionObjectReference_To_v2_CrossVersionObjectReference(a.(*autoscaling.CrossVersionObjectReference), b.(*autoscalingv2.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.ExternalMetricSource)(nil), (*autoscaling.ExternalMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_ExternalMetricSource_To_autoscaling_ExternalMetricSource(a.(*autoscalingv2.ExternalMetricSource), b.(*autoscaling.ExternalMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ExternalMetricSource)(nil), (*autoscalingv2.ExternalMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ExternalMetricSource_To_v2_ExternalMetricSource(a.(*autoscaling.ExternalMetricSource), b.(*autoscalingv2.ExternalMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.ExternalMetricStatus)(nil), (*autoscaling.ExternalMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(a.(*autoscalingv2.ExternalMetricStatus), b.(*autoscaling.ExternalMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ExternalMetricStatus)(nil), (*autoscalingv2.ExternalMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ExternalMetricStatus_To_v2_ExternalMetricStatus(a.(*autoscaling.ExternalMetricStatus), b.(*autoscalingv2.ExternalMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.HPAScalingPolicy)(nil), (*autoscaling.HPAScalingPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy(a.(*autoscalingv2.HPAScalingPolicy), b.(*autoscaling.HPAScalingPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HPAScalingPolicy)(nil), (*autoscalingv2.HPAScalingPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HPAScalingPolicy_To_v2_HPAScalingPolicy(a.(*autoscaling.HPAScalingPolicy), b.(*autoscalingv2.HPAScalingPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.HPAScalingRules)(nil), (*autoscaling.HPAScalingRules)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_HPAScalingRules_To_autoscaling_HPAScalingRules(a.(*autoscalingv2.HPAScalingRules), b.(*autoscaling.HPAScalingRules), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HPAScalingRules)(nil), (*autoscalingv2.HPAScalingRules)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HPAScalingRules_To_v2_HPAScalingRules(a.(*autoscaling.HPAScalingRules), b.(*autoscalingv2.HPAScalingRules), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.HorizontalPodAutoscalerBehavior)(nil), (*autoscaling.HorizontalPodAutoscalerBehavior)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(a.(*autoscalingv2.HorizontalPodAutoscalerBehavior), b.(*autoscaling.HorizontalPodAutoscalerBehavior), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerBehavior)(nil), (*autoscalingv2.HorizontalPodAutoscalerBehavior)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2_HorizontalPodAutoscalerBehavior(a.(*autoscaling.HorizontalPodAutoscalerBehavior), b.(*autoscalingv2.HorizontalPodAutoscalerBehavior), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.HorizontalPodAutoscalerCondition)(nil), (*autoscaling.HorizontalPodAutoscalerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(a.(*autoscalingv2.HorizontalPodAutoscalerCondition), b.(*autoscaling.HorizontalPodAutoscalerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerCondition)(nil), (*autoscalingv2.HorizontalPodAutoscalerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2_HorizontalPodAutoscalerCondition(a.(*autoscaling.HorizontalPodAutoscalerCondition), b.(*autoscalingv2.HorizontalPodAutoscalerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.HorizontalPodAutoscalerList)(nil), (*autoscaling.HorizontalPodAutoscalerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(a.(*autoscalingv2.HorizontalPodAutoscalerList), b.(*autoscaling.HorizontalPodAutoscalerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerList)(nil), (*autoscalingv2.HorizontalPodAutoscalerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerList_To_v2_HorizontalPodAutoscalerList(a.(*autoscaling.HorizontalPodAutoscalerList), b.(*autoscalingv2.HorizontalPodAutoscalerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.HorizontalPodAutoscalerSpec)(nil), (*autoscaling.HorizontalPodAutoscalerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(a.(*autoscalingv2.HorizontalPodAutoscalerSpec), b.(*autoscaling.HorizontalPodAutoscalerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerSpec)(nil), (*autoscalingv2.HorizontalPodAutoscalerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2_HorizontalPodAutoscalerSpec(a.(*autoscaling.HorizontalPodAutoscalerSpec), b.(*autoscalingv2.HorizontalPodAutoscalerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.HorizontalPodAutoscalerStatus)(nil), (*autoscaling.HorizontalPodAutoscalerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(a.(*autoscalingv2.HorizontalPodAutoscalerStatus), b.(*autoscaling.HorizontalPodAutoscalerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerStatus)(nil), (*autoscalingv2.HorizontalPodAutoscalerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2_HorizontalPodAutoscalerStatus(a.(*autoscaling.HorizontalPodAutoscalerStatus), b.(*autoscalingv2.HorizontalPodAutoscalerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.MetricIdentifier)(nil), (*autoscaling.MetricIdentifier)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(a.(*autoscalingv2.MetricIdentifier), b.(*autoscaling.MetricIdentifier), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricIdentifier)(nil), (*autoscalingv2.MetricIdentifier)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(a.(*autoscaling.MetricIdentifier), b.(*autoscalingv2.MetricIdentifier), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.MetricSpec)(nil), (*autoscaling.MetricSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_MetricSpec_To_autoscaling_MetricSpec(a.(*autoscalingv2.MetricSpec), b.(*autoscaling.MetricSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricSpec)(nil), (*autoscalingv2.MetricSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricSpec_To_v2_MetricSpec(a.(*autoscaling.MetricSpec), b.(*autoscalingv2.MetricSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.MetricStatus)(nil), (*autoscaling.MetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_MetricStatus_To_autoscaling_MetricStatus(a.(*autoscalingv2.MetricStatus), b.(*autoscaling.MetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricStatus)(nil), (*autoscalingv2.MetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricStatus_To_v2_MetricStatus(a.(*autoscaling.MetricStatus), b.(*autoscalingv2.MetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.MetricTarget)(nil), (*autoscaling.MetricTarget)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_MetricTarget_To_autoscaling_MetricTarget(a.(*autoscalingv2.MetricTarget), b.(*autoscaling.MetricTarget), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricTarget)(nil), (*autoscalingv2.MetricTarget)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricTarget_To_v2_MetricTarget(a.(*autoscaling.MetricTarget), b.(*autoscalingv2.MetricTarget), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.MetricValueStatus)(nil), (*autoscaling.MetricValueStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(a.(*autoscalingv2.MetricValueStatus), b.(*autoscaling.MetricValueStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricValueStatus)(nil), (*autoscalingv2.MetricValueStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(a.(*autoscaling.MetricValueStatus), b.(*autoscalingv2.MetricValueStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.ObjectMetricSource)(nil), (*autoscaling.ObjectMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_ObjectMetricSource_To_autoscaling_ObjectMetricSource(a.(*autoscalingv2.ObjectMetricSource), b.(*autoscaling.ObjectMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ObjectMetricSource)(nil), (*autoscalingv2.ObjectMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ObjectMetricSource_To_v2_ObjectMetricSource(a.(*autoscaling.ObjectMetricSource), b.(*autoscalingv2.ObjectMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.ObjectMetricStatus)(nil), (*autoscaling.ObjectMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(a.(*autoscalingv2.ObjectMetricStatus), b.(*autoscaling.ObjectMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ObjectMetricStatus)(nil), (*autoscalingv2.ObjectMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ObjectMetricStatus_To_v2_ObjectMetricStatus(a.(*autoscaling.ObjectMetricStatus), b.(*autoscalingv2.ObjectMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.PodsMetricSource)(nil), (*autoscaling.PodsMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_PodsMetricSource_To_autoscaling_PodsMetricSource(a.(*autoscalingv2.PodsMetricSource), b.(*autoscaling.PodsMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.PodsMetricSource)(nil), (*autoscalingv2.PodsMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_PodsMetricSource_To_v2_PodsMetricSource(a.(*autoscaling.PodsMetricSource), b.(*autoscalingv2.PodsMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.PodsMetricStatus)(nil), (*autoscaling.PodsMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_PodsMetricStatus_To_autoscaling_PodsMetricStatus(a.(*autoscalingv2.PodsMetricStatus), b.(*autoscaling.PodsMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.PodsMetricStatus)(nil), (*autoscalingv2.PodsMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_PodsMetricStatus_To_v2_PodsMetricStatus(a.(*autoscaling.PodsMetricStatus), b.(*autoscalingv2.PodsMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.ResourceMetricSource)(nil), (*autoscaling.ResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_ResourceMetricSource_To_autoscaling_ResourceMetricSource(a.(*autoscalingv2.ResourceMetricSource), b.(*autoscaling.ResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ResourceMetricSource)(nil), (*autoscalingv2.ResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ResourceMetricSource_To_v2_ResourceMetricSource(a.(*autoscaling.ResourceMetricSource), b.(*autoscalingv2.ResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2.ResourceMetricStatus)(nil), (*autoscaling.ResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(a.(*autoscalingv2.ResourceMetricStatus), b.(*autoscaling.ResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ResourceMetricStatus)(nil), (*autoscalingv2.ResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ResourceMetricStatus_To_v2_ResourceMetricStatus(a.(*autoscaling.ResourceMetricStatus), b.(*autoscalingv2.ResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.HorizontalPodAutoscaler)(nil), (*autoscalingv2.HorizontalPodAutoscaler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscaler_To_v2_HorizontalPodAutoscaler(a.(*autoscaling.HorizontalPodAutoscaler), b.(*autoscalingv2.HorizontalPodAutoscaler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2.HorizontalPodAutoscaler)(nil), (*autoscaling.HorizontalPodAutoscaler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(a.(*autoscalingv2.HorizontalPodAutoscaler), b.(*autoscaling.HorizontalPodAutoscaler), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in *autoscalingv2.ContainerResourceMetricSource, out *autoscaling.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        if err := Convert_v2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        out.Container = in.Container
        return nil
}

// Convert_v2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource is an autogenerated conversion function.
func Convert_v2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in *autoscalingv2.ContainerResourceMetricSource, out *autoscaling.ContainerResourceMetricSource, s conversion.Scope) error {
        return autoConvert_v2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in, out, s)
}

func autoConvert_autoscaling_ContainerResourceMetricSource_To_v2_ContainerResourceMetricSource(in *autoscaling.ContainerResourceMetricSource, out *autoscalingv2.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        if err := Convert_autoscaling_MetricTarget_To_v2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ContainerResourceMetricSource_To_v2_ContainerResourceMetricSource is an autogenerated conversion function.
func Convert_autoscaling_ContainerResourceMetricSource_To_v2_ContainerResourceMetricSource(in *autoscaling.ContainerResourceMetricSource, out *autoscalingv2.ContainerResourceMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_ContainerResourceMetricSource_To_v2_ContainerResourceMetricSource(in, out, s)
}

func autoConvert_v2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in *autoscalingv2.ContainerResourceMetricStatus, out *autoscaling.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        if err := Convert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        out.Container = in.Container
        return nil
}

// Convert_v2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus is an autogenerated conversion function.
func Convert_v2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in *autoscalingv2.ContainerResourceMetricStatus, out *autoscaling.ContainerResourceMetricStatus, s conversion.Scope) error {
        return autoConvert_v2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in, out, s)
}

func autoConvert_autoscaling_ContainerResourceMetricStatus_To_v2_ContainerResourceMetricStatus(in *autoscaling.ContainerResourceMetricStatus, out *autoscalingv2.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        if err := Convert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ContainerResourceMetricStatus_To_v2_ContainerResourceMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_ContainerResourceMetricStatus_To_v2_ContainerResourceMetricStatus(in *autoscaling.ContainerResourceMetricStatus, out *autoscalingv2.ContainerResourceMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ContainerResourceMetricStatus_To_v2_ContainerResourceMetricStatus(in, out, s)
}

func autoConvert_v2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *autoscalingv2.CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Name = in.Name
        out.APIVersion = in.APIVersion
        return nil
}

// Convert_v2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference is an autogenerated conversion function.
func Convert_v2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *autoscalingv2.CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
        return autoConvert_v2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in, out, s)
}

func autoConvert_autoscaling_CrossVersionObjectReference_To_v2_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *autoscalingv2.CrossVersionObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Name = in.Name
        out.APIVersion = in.APIVersion
        return nil
}

// Convert_autoscaling_CrossVersionObjectReference_To_v2_CrossVersionObjectReference is an autogenerated conversion function.
func Convert_autoscaling_CrossVersionObjectReference_To_v2_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *autoscalingv2.CrossVersionObjectReference, s conversion.Scope) error {
        return autoConvert_autoscaling_CrossVersionObjectReference_To_v2_CrossVersionObjectReference(in, out, s)
}

func autoConvert_v2_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in *autoscalingv2.ExternalMetricSource, out *autoscaling.ExternalMetricSource, s conversion.Scope) error {
        if err := Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2_ExternalMetricSource_To_autoscaling_ExternalMetricSource is an autogenerated conversion function.
func Convert_v2_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in *autoscalingv2.ExternalMetricSource, out *autoscaling.ExternalMetricSource, s conversion.Scope) error {
        return autoConvert_v2_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in, out, s)
}

func autoConvert_autoscaling_ExternalMetricSource_To_v2_ExternalMetricSource(in *autoscaling.ExternalMetricSource, out *autoscalingv2.ExternalMetricSource, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricTarget_To_v2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ExternalMetricSource_To_v2_ExternalMetricSource is an autogenerated conversion function.
func Convert_autoscaling_ExternalMetricSource_To_v2_ExternalMetricSource(in *autoscaling.ExternalMetricSource, out *autoscalingv2.ExternalMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_ExternalMetricSource_To_v2_ExternalMetricSource(in, out, s)
}

func autoConvert_v2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in *autoscalingv2.ExternalMetricStatus, out *autoscaling.ExternalMetricStatus, s conversion.Scope) error {
        if err := Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus is an autogenerated conversion function.
func Convert_v2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in *autoscalingv2.ExternalMetricStatus, out *autoscaling.ExternalMetricStatus, s conversion.Scope) error {
        return autoConvert_v2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in, out, s)
}

func autoConvert_autoscaling_ExternalMetricStatus_To_v2_ExternalMetricStatus(in *autoscaling.ExternalMetricStatus, out *autoscalingv2.ExternalMetricStatus, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ExternalMetricStatus_To_v2_ExternalMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_ExternalMetricStatus_To_v2_ExternalMetricStatus(in *autoscaling.ExternalMetricStatus, out *autoscalingv2.ExternalMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ExternalMetricStatus_To_v2_ExternalMetricStatus(in, out, s)
}

func autoConvert_v2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy(in *autoscalingv2.HPAScalingPolicy, out *autoscaling.HPAScalingPolicy, s conversion.Scope) error {
        out.Type = autoscaling.HPAScalingPolicyType(in.Type)
        out.Value = in.Value
        out.PeriodSeconds = in.PeriodSeconds
        return nil
}

// Convert_v2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy is an autogenerated conversion function.
func Convert_v2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy(in *autoscalingv2.HPAScalingPolicy, out *autoscaling.HPAScalingPolicy, s conversion.Scope) error {
        return autoConvert_v2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy(in, out, s)
}

func autoConvert_autoscaling_HPAScalingPolicy_To_v2_HPAScalingPolicy(in *autoscaling.HPAScalingPolicy, out *autoscalingv2.HPAScalingPolicy, s conversion.Scope) error {
        out.Type = autoscalingv2.HPAScalingPolicyType(in.Type)
        out.Value = in.Value
        out.PeriodSeconds = in.PeriodSeconds
        return nil
}

// Convert_autoscaling_HPAScalingPolicy_To_v2_HPAScalingPolicy is an autogenerated conversion function.
func Convert_autoscaling_HPAScalingPolicy_To_v2_HPAScalingPolicy(in *autoscaling.HPAScalingPolicy, out *autoscalingv2.HPAScalingPolicy, s conversion.Scope) error {
        return autoConvert_autoscaling_HPAScalingPolicy_To_v2_HPAScalingPolicy(in, out, s)
}

func autoConvert_v2_HPAScalingRules_To_autoscaling_HPAScalingRules(in *autoscalingv2.HPAScalingRules, out *autoscaling.HPAScalingRules, s conversion.Scope) error {
        out.StabilizationWindowSeconds = (*int32)(unsafe.Pointer(in.StabilizationWindowSeconds))
        out.SelectPolicy = (*autoscaling.ScalingPolicySelect)(unsafe.Pointer(in.SelectPolicy))
        out.Policies = *(*[]autoscaling.HPAScalingPolicy)(unsafe.Pointer(&in.Policies))
        out.Tolerance = (*resource.Quantity)(unsafe.Pointer(in.Tolerance))
        return nil
}

// Convert_v2_HPAScalingRules_To_autoscaling_HPAScalingRules is an autogenerated conversion function.
func Convert_v2_HPAScalingRules_To_autoscaling_HPAScalingRules(in *autoscalingv2.HPAScalingRules, out *autoscaling.HPAScalingRules, s conversion.Scope) error {
        return autoConvert_v2_HPAScalingRules_To_autoscaling_HPAScalingRules(in, out, s)
}

func autoConvert_autoscaling_HPAScalingRules_To_v2_HPAScalingRules(in *autoscaling.HPAScalingRules, out *autoscalingv2.HPAScalingRules, s conversion.Scope) error {
        out.StabilizationWindowSeconds = (*int32)(unsafe.Pointer(in.StabilizationWindowSeconds))
        out.SelectPolicy = (*autoscalingv2.ScalingPolicySelect)(unsafe.Pointer(in.SelectPolicy))
        out.Policies = *(*[]autoscalingv2.HPAScalingPolicy)(unsafe.Pointer(&in.Policies))
        out.Tolerance = (*resource.Quantity)(unsafe.Pointer(in.Tolerance))
        return nil
}

// Convert_autoscaling_HPAScalingRules_To_v2_HPAScalingRules is an autogenerated conversion function.
func Convert_autoscaling_HPAScalingRules_To_v2_HPAScalingRules(in *autoscaling.HPAScalingRules, out *autoscalingv2.HPAScalingRules, s conversion.Scope) error {
        return autoConvert_autoscaling_HPAScalingRules_To_v2_HPAScalingRules(in, out, s)
}

func autoConvert_v2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *autoscalingv2.HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_autoscaling_HorizontalPodAutoscaler_To_v2_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *autoscalingv2.HorizontalPodAutoscaler, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(in *autoscalingv2.HorizontalPodAutoscalerBehavior, out *autoscaling.HorizontalPodAutoscalerBehavior, s conversion.Scope) error {
        out.ScaleUp = (*autoscaling.HPAScalingRules)(unsafe.Pointer(in.ScaleUp))
        out.ScaleDown = (*autoscaling.HPAScalingRules)(unsafe.Pointer(in.ScaleDown))
        return nil
}

// Convert_v2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior is an autogenerated conversion function.
func Convert_v2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(in *autoscalingv2.HorizontalPodAutoscalerBehavior, out *autoscaling.HorizontalPodAutoscalerBehavior, s conversion.Scope) error {
        return autoConvert_v2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2_HorizontalPodAutoscalerBehavior(in *autoscaling.HorizontalPodAutoscalerBehavior, out *autoscalingv2.HorizontalPodAutoscalerBehavior, s conversion.Scope) error {
        out.ScaleUp = (*autoscalingv2.HPAScalingRules)(unsafe.Pointer(in.ScaleUp))
        out.ScaleDown = (*autoscalingv2.HPAScalingRules)(unsafe.Pointer(in.ScaleDown))
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2_HorizontalPodAutoscalerBehavior is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2_HorizontalPodAutoscalerBehavior(in *autoscaling.HorizontalPodAutoscalerBehavior, out *autoscalingv2.HorizontalPodAutoscalerBehavior, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2_HorizontalPodAutoscalerBehavior(in, out, s)
}

func autoConvert_v2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in *autoscalingv2.HorizontalPodAutoscalerCondition, out *autoscaling.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        out.Type = autoscaling.HorizontalPodAutoscalerConditionType(in.Type)
        out.Status = autoscaling.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition is an autogenerated conversion function.
func Convert_v2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in *autoscalingv2.HorizontalPodAutoscalerCondition, out *autoscaling.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        return autoConvert_v2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerCondition_To_v2_HorizontalPodAutoscalerCondition(in *autoscaling.HorizontalPodAutoscalerCondition, out *autoscalingv2.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        out.Type = autoscalingv2.HorizontalPodAutoscalerConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2_HorizontalPodAutoscalerCondition is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2_HorizontalPodAutoscalerCondition(in *autoscaling.HorizontalPodAutoscalerCondition, out *autoscalingv2.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerCondition_To_v2_HorizontalPodAutoscalerCondition(in, out, s)
}

func autoConvert_v2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *autoscalingv2.HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]autoscaling.HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        if err := Convert_v2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList is an autogenerated conversion function.
func Convert_v2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *autoscalingv2.HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
        return autoConvert_v2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v2_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *autoscalingv2.HorizontalPodAutoscalerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]autoscalingv2.HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_HorizontalPodAutoscaler_To_v2_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerList_To_v2_HorizontalPodAutoscalerList is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerList_To_v2_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *autoscalingv2.HorizontalPodAutoscalerList, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v2_HorizontalPodAutoscalerList(in, out, s)
}

func autoConvert_v2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *autoscalingv2.HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_v2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }
        out.MinReplicas = (*int32)(unsafe.Pointer(in.MinReplicas))
        out.MaxReplicas = in.MaxReplicas
        if in.Metrics != nil {
                in, out := &in.Metrics, &out.Metrics
                *out = make([]autoscaling.MetricSpec, len(*in))
                for i := range *in {
                        if err := Convert_v2_MetricSpec_To_autoscaling_MetricSpec(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Metrics = nil
        }
        out.Behavior = (*autoscaling.HorizontalPodAutoscalerBehavior)(unsafe.Pointer(in.Behavior))
        return nil
}

// Convert_v2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec is an autogenerated conversion function.
func Convert_v2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *autoscalingv2.HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        return autoConvert_v2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v2_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *autoscalingv2.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v2_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }
        out.MinReplicas = (*int32)(unsafe.Pointer(in.MinReplicas))
        out.MaxReplicas = in.MaxReplicas
        if in.Metrics != nil {
                in, out := &in.Metrics, &out.Metrics
                *out = make([]autoscalingv2.MetricSpec, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_MetricSpec_To_v2_MetricSpec(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Metrics = nil
        }
        out.Behavior = (*autoscalingv2.HorizontalPodAutoscalerBehavior)(unsafe.Pointer(in.Behavior))
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2_HorizontalPodAutoscalerSpec is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *autoscalingv2.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v2_HorizontalPodAutoscalerSpec(in, out, s)
}

func autoConvert_v2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *autoscalingv2.HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.LastScaleTime = (*metav1.Time)(unsafe.Pointer(in.LastScaleTime))
        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas
        if in.CurrentMetrics != nil {
                in, out := &in.CurrentMetrics, &out.CurrentMetrics
                *out = make([]autoscaling.MetricStatus, len(*in))
                for i := range *in {
                        if err := Convert_v2_MetricStatus_To_autoscaling_MetricStatus(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.CurrentMetrics = nil
        }
        out.Conditions = *(*[]autoscaling.HorizontalPodAutoscalerCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus is an autogenerated conversion function.
func Convert_v2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *autoscalingv2.HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        return autoConvert_v2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v2_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *autoscalingv2.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.LastScaleTime = (*metav1.Time)(unsafe.Pointer(in.LastScaleTime))
        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas
        if in.CurrentMetrics != nil {
                in, out := &in.CurrentMetrics, &out.CurrentMetrics
                *out = make([]autoscalingv2.MetricStatus, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_MetricStatus_To_v2_MetricStatus(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.CurrentMetrics = nil
        }
        out.Conditions = *(*[]autoscalingv2.HorizontalPodAutoscalerCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2_HorizontalPodAutoscalerStatus is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *autoscalingv2.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v2_HorizontalPodAutoscalerStatus(in, out, s)
}

func autoConvert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(in *autoscalingv2.MetricIdentifier, out *autoscaling.MetricIdentifier, s conversion.Scope) error {
        out.Name = in.Name
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        return nil
}

// Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier is an autogenerated conversion function.
func Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(in *autoscalingv2.MetricIdentifier, out *autoscaling.MetricIdentifier, s conversion.Scope) error {
        return autoConvert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(in, out, s)
}

func autoConvert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(in *autoscaling.MetricIdentifier, out *autoscalingv2.MetricIdentifier, s conversion.Scope) error {
        out.Name = in.Name
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        return nil
}

// Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier is an autogenerated conversion function.
func Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(in *autoscaling.MetricIdentifier, out *autoscalingv2.MetricIdentifier, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(in, out, s)
}

func autoConvert_v2_MetricSpec_To_autoscaling_MetricSpec(in *autoscalingv2.MetricSpec, out *autoscaling.MetricSpec, s conversion.Scope) error {
        out.Type = autoscaling.MetricSourceType(in.Type)
        out.Object = (*autoscaling.ObjectMetricSource)(unsafe.Pointer(in.Object))
        out.Pods = (*autoscaling.PodsMetricSource)(unsafe.Pointer(in.Pods))
        out.Resource = (*autoscaling.ResourceMetricSource)(unsafe.Pointer(in.Resource))
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscaling.ContainerResourceMetricSource)
                if err := Convert_v2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        out.External = (*autoscaling.ExternalMetricSource)(unsafe.Pointer(in.External))
        return nil
}

// Convert_v2_MetricSpec_To_autoscaling_MetricSpec is an autogenerated conversion function.
func Convert_v2_MetricSpec_To_autoscaling_MetricSpec(in *autoscalingv2.MetricSpec, out *autoscaling.MetricSpec, s conversion.Scope) error {
        return autoConvert_v2_MetricSpec_To_autoscaling_MetricSpec(in, out, s)
}

func autoConvert_autoscaling_MetricSpec_To_v2_MetricSpec(in *autoscaling.MetricSpec, out *autoscalingv2.MetricSpec, s conversion.Scope) error {
        out.Type = autoscalingv2.MetricSourceType(in.Type)
        out.Object = (*autoscalingv2.ObjectMetricSource)(unsafe.Pointer(in.Object))
        out.Pods = (*autoscalingv2.PodsMetricSource)(unsafe.Pointer(in.Pods))
        out.Resource = (*autoscalingv2.ResourceMetricSource)(unsafe.Pointer(in.Resource))
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscalingv2.ContainerResourceMetricSource)
                if err := Convert_autoscaling_ContainerResourceMetricSource_To_v2_ContainerResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        out.External = (*autoscalingv2.ExternalMetricSource)(unsafe.Pointer(in.External))
        return nil
}

// Convert_autoscaling_MetricSpec_To_v2_MetricSpec is an autogenerated conversion function.
func Convert_autoscaling_MetricSpec_To_v2_MetricSpec(in *autoscaling.MetricSpec, out *autoscalingv2.MetricSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricSpec_To_v2_MetricSpec(in, out, s)
}

func autoConvert_v2_MetricStatus_To_autoscaling_MetricStatus(in *autoscalingv2.MetricStatus, out *autoscaling.MetricStatus, s conversion.Scope) error {
        out.Type = autoscaling.MetricSourceType(in.Type)
        out.Object = (*autoscaling.ObjectMetricStatus)(unsafe.Pointer(in.Object))
        out.Pods = (*autoscaling.PodsMetricStatus)(unsafe.Pointer(in.Pods))
        out.Resource = (*autoscaling.ResourceMetricStatus)(unsafe.Pointer(in.Resource))
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscaling.ContainerResourceMetricStatus)
                if err := Convert_v2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        out.External = (*autoscaling.ExternalMetricStatus)(unsafe.Pointer(in.External))
        return nil
}

// Convert_v2_MetricStatus_To_autoscaling_MetricStatus is an autogenerated conversion function.
func Convert_v2_MetricStatus_To_autoscaling_MetricStatus(in *autoscalingv2.MetricStatus, out *autoscaling.MetricStatus, s conversion.Scope) error {
        return autoConvert_v2_MetricStatus_To_autoscaling_MetricStatus(in, out, s)
}

func autoConvert_autoscaling_MetricStatus_To_v2_MetricStatus(in *autoscaling.MetricStatus, out *autoscalingv2.MetricStatus, s conversion.Scope) error {
        out.Type = autoscalingv2.MetricSourceType(in.Type)
        out.Object = (*autoscalingv2.ObjectMetricStatus)(unsafe.Pointer(in.Object))
        out.Pods = (*autoscalingv2.PodsMetricStatus)(unsafe.Pointer(in.Pods))
        out.Resource = (*autoscalingv2.ResourceMetricStatus)(unsafe.Pointer(in.Resource))
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscalingv2.ContainerResourceMetricStatus)
                if err := Convert_autoscaling_ContainerResourceMetricStatus_To_v2_ContainerResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        out.External = (*autoscalingv2.ExternalMetricStatus)(unsafe.Pointer(in.External))
        return nil
}

// Convert_autoscaling_MetricStatus_To_v2_MetricStatus is an autogenerated conversion function.
func Convert_autoscaling_MetricStatus_To_v2_MetricStatus(in *autoscaling.MetricStatus, out *autoscalingv2.MetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricStatus_To_v2_MetricStatus(in, out, s)
}

func autoConvert_v2_MetricTarget_To_autoscaling_MetricTarget(in *autoscalingv2.MetricTarget, out *autoscaling.MetricTarget, s conversion.Scope) error {
        out.Type = autoscaling.MetricTargetType(in.Type)
        out.Value = (*resource.Quantity)(unsafe.Pointer(in.Value))
        out.AverageValue = (*resource.Quantity)(unsafe.Pointer(in.AverageValue))
        out.AverageUtilization = (*int32)(unsafe.Pointer(in.AverageUtilization))
        return nil
}

// Convert_v2_MetricTarget_To_autoscaling_MetricTarget is an autogenerated conversion function.
func Convert_v2_MetricTarget_To_autoscaling_MetricTarget(in *autoscalingv2.MetricTarget, out *autoscaling.MetricTarget, s conversion.Scope) error {
        return autoConvert_v2_MetricTarget_To_autoscaling_MetricTarget(in, out, s)
}

func autoConvert_autoscaling_MetricTarget_To_v2_MetricTarget(in *autoscaling.MetricTarget, out *autoscalingv2.MetricTarget, s conversion.Scope) error {
        out.Type = autoscalingv2.MetricTargetType(in.Type)
        out.Value = (*resource.Quantity)(unsafe.Pointer(in.Value))
        out.AverageValue = (*resource.Quantity)(unsafe.Pointer(in.AverageValue))
        out.AverageUtilization = (*int32)(unsafe.Pointer(in.AverageUtilization))
        return nil
}

// Convert_autoscaling_MetricTarget_To_v2_MetricTarget is an autogenerated conversion function.
func Convert_autoscaling_MetricTarget_To_v2_MetricTarget(in *autoscaling.MetricTarget, out *autoscalingv2.MetricTarget, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricTarget_To_v2_MetricTarget(in, out, s)
}

func autoConvert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(in *autoscalingv2.MetricValueStatus, out *autoscaling.MetricValueStatus, s conversion.Scope) error {
        out.Value = (*resource.Quantity)(unsafe.Pointer(in.Value))
        out.AverageValue = (*resource.Quantity)(unsafe.Pointer(in.AverageValue))
        out.AverageUtilization = (*int32)(unsafe.Pointer(in.AverageUtilization))
        return nil
}

// Convert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus is an autogenerated conversion function.
func Convert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(in *autoscalingv2.MetricValueStatus, out *autoscaling.MetricValueStatus, s conversion.Scope) error {
        return autoConvert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(in, out, s)
}

func autoConvert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(in *autoscaling.MetricValueStatus, out *autoscalingv2.MetricValueStatus, s conversion.Scope) error {
        out.Value = (*resource.Quantity)(unsafe.Pointer(in.Value))
        out.AverageValue = (*resource.Quantity)(unsafe.Pointer(in.AverageValue))
        out.AverageUtilization = (*int32)(unsafe.Pointer(in.AverageUtilization))
        return nil
}

// Convert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus is an autogenerated conversion function.
func Convert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(in *autoscaling.MetricValueStatus, out *autoscalingv2.MetricValueStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(in, out, s)
}

func autoConvert_v2_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in *autoscalingv2.ObjectMetricSource, out *autoscaling.ObjectMetricSource, s conversion.Scope) error {
        if err := Convert_v2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.DescribedObject, &out.DescribedObject, s); err != nil {
                return err
        }
        if err := Convert_v2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        if err := Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2_ObjectMetricSource_To_autoscaling_ObjectMetricSource is an autogenerated conversion function.
func Convert_v2_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in *autoscalingv2.ObjectMetricSource, out *autoscaling.ObjectMetricSource, s conversion.Scope) error {
        return autoConvert_v2_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in, out, s)
}

func autoConvert_autoscaling_ObjectMetricSource_To_v2_ObjectMetricSource(in *autoscaling.ObjectMetricSource, out *autoscalingv2.ObjectMetricSource, s conversion.Scope) error {
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v2_CrossVersionObjectReference(&in.DescribedObject, &out.DescribedObject, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricTarget_To_v2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ObjectMetricSource_To_v2_ObjectMetricSource is an autogenerated conversion function.
func Convert_autoscaling_ObjectMetricSource_To_v2_ObjectMetricSource(in *autoscaling.ObjectMetricSource, out *autoscalingv2.ObjectMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_ObjectMetricSource_To_v2_ObjectMetricSource(in, out, s)
}

func autoConvert_v2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in *autoscalingv2.ObjectMetricStatus, out *autoscaling.ObjectMetricStatus, s conversion.Scope) error {
        if err := Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        if err := Convert_v2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.DescribedObject, &out.DescribedObject, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus is an autogenerated conversion function.
func Convert_v2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in *autoscalingv2.ObjectMetricStatus, out *autoscaling.ObjectMetricStatus, s conversion.Scope) error {
        return autoConvert_v2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in, out, s)
}

func autoConvert_autoscaling_ObjectMetricStatus_To_v2_ObjectMetricStatus(in *autoscaling.ObjectMetricStatus, out *autoscalingv2.ObjectMetricStatus, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v2_CrossVersionObjectReference(&in.DescribedObject, &out.DescribedObject, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ObjectMetricStatus_To_v2_ObjectMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_ObjectMetricStatus_To_v2_ObjectMetricStatus(in *autoscaling.ObjectMetricStatus, out *autoscalingv2.ObjectMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ObjectMetricStatus_To_v2_ObjectMetricStatus(in, out, s)
}

func autoConvert_v2_PodsMetricSource_To_autoscaling_PodsMetricSource(in *autoscalingv2.PodsMetricSource, out *autoscaling.PodsMetricSource, s conversion.Scope) error {
        if err := Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2_PodsMetricSource_To_autoscaling_PodsMetricSource is an autogenerated conversion function.
func Convert_v2_PodsMetricSource_To_autoscaling_PodsMetricSource(in *autoscalingv2.PodsMetricSource, out *autoscaling.PodsMetricSource, s conversion.Scope) error {
        return autoConvert_v2_PodsMetricSource_To_autoscaling_PodsMetricSource(in, out, s)
}

func autoConvert_autoscaling_PodsMetricSource_To_v2_PodsMetricSource(in *autoscaling.PodsMetricSource, out *autoscalingv2.PodsMetricSource, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricTarget_To_v2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_PodsMetricSource_To_v2_PodsMetricSource is an autogenerated conversion function.
func Convert_autoscaling_PodsMetricSource_To_v2_PodsMetricSource(in *autoscaling.PodsMetricSource, out *autoscalingv2.PodsMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_PodsMetricSource_To_v2_PodsMetricSource(in, out, s)
}

func autoConvert_v2_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in *autoscalingv2.PodsMetricStatus, out *autoscaling.PodsMetricStatus, s conversion.Scope) error {
        if err := Convert_v2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2_PodsMetricStatus_To_autoscaling_PodsMetricStatus is an autogenerated conversion function.
func Convert_v2_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in *autoscalingv2.PodsMetricStatus, out *autoscaling.PodsMetricStatus, s conversion.Scope) error {
        return autoConvert_v2_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in, out, s)
}

func autoConvert_autoscaling_PodsMetricStatus_To_v2_PodsMetricStatus(in *autoscaling.PodsMetricStatus, out *autoscalingv2.PodsMetricStatus, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_PodsMetricStatus_To_v2_PodsMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_PodsMetricStatus_To_v2_PodsMetricStatus(in *autoscaling.PodsMetricStatus, out *autoscalingv2.PodsMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_PodsMetricStatus_To_v2_PodsMetricStatus(in, out, s)
}

func autoConvert_v2_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in *autoscalingv2.ResourceMetricSource, out *autoscaling.ResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        if err := Convert_v2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2_ResourceMetricSource_To_autoscaling_ResourceMetricSource is an autogenerated conversion function.
func Convert_v2_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in *autoscalingv2.ResourceMetricSource, out *autoscaling.ResourceMetricSource, s conversion.Scope) error {
        return autoConvert_v2_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in, out, s)
}

func autoConvert_autoscaling_ResourceMetricSource_To_v2_ResourceMetricSource(in *autoscaling.ResourceMetricSource, out *autoscalingv2.ResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        if err := Convert_autoscaling_MetricTarget_To_v2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ResourceMetricSource_To_v2_ResourceMetricSource is an autogenerated conversion function.
func Convert_autoscaling_ResourceMetricSource_To_v2_ResourceMetricSource(in *autoscaling.ResourceMetricSource, out *autoscalingv2.ResourceMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_ResourceMetricSource_To_v2_ResourceMetricSource(in, out, s)
}

func autoConvert_v2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in *autoscalingv2.ResourceMetricStatus, out *autoscaling.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        if err := Convert_v2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus is an autogenerated conversion function.
func Convert_v2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in *autoscalingv2.ResourceMetricStatus, out *autoscaling.ResourceMetricStatus, s conversion.Scope) error {
        return autoConvert_v2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in, out, s)
}

func autoConvert_autoscaling_ResourceMetricStatus_To_v2_ResourceMetricStatus(in *autoscaling.ResourceMetricStatus, out *autoscalingv2.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        if err := Convert_autoscaling_MetricValueStatus_To_v2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ResourceMetricStatus_To_v2_ResourceMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_ResourceMetricStatus_To_v2_ResourceMetricStatus(in *autoscaling.ResourceMetricStatus, out *autoscalingv2.ResourceMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ResourceMetricStatus_To_v2_ResourceMetricStatus(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v2

import (
        autoscalingv2 "k8s.io/api/autoscaling/v2"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&autoscalingv2.HorizontalPodAutoscaler{}, func(obj interface{}) {
                SetObjectDefaults_HorizontalPodAutoscaler(obj.(*autoscalingv2.HorizontalPodAutoscaler))
        })
        scheme.AddTypeDefaultingFunc(&autoscalingv2.HorizontalPodAutoscalerList{}, func(obj interface{}) {
                SetObjectDefaults_HorizontalPodAutoscalerList(obj.(*autoscalingv2.HorizontalPodAutoscalerList))
        })
        return nil
}

func SetObjectDefaults_HorizontalPodAutoscaler(in *autoscalingv2.HorizontalPodAutoscaler) {
        SetDefaults_HorizontalPodAutoscaler(in)
}

func SetObjectDefaults_HorizontalPodAutoscalerList(in *autoscalingv2.HorizontalPodAutoscalerList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_HorizontalPodAutoscaler(a)
        }
}

/*
Copyright 2018 The Kubernetes Authors.

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.
*/

package v2beta1

import (
        "encoding/json"

        autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1"

        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func Convert_autoscaling_MetricTarget_To_v2beta1_CrossVersionObjectReference(in *autoscaling.MetricTarget, out *autoscalingv2beta1.CrossVersionObjectReference, s conversion.Scope) error {
        return nil
}

func Convert_v2beta1_CrossVersionObjectReference_To_autoscaling_MetricTarget(in *autoscalingv2beta1.CrossVersionObjectReference, out *autoscaling.MetricTarget, s conversion.Scope) error {
        return nil
}

func Convert_v2beta1_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in *autoscalingv2beta1.ContainerResourceMetricStatus, out *autoscaling.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        out.Container = in.Container
        utilization := in.CurrentAverageUtilization
        averageValue := in.CurrentAverageValue
        out.Current = autoscaling.MetricValueStatus{
                AverageValue:       &averageValue,
                AverageUtilization: utilization,
        }
        return nil
}

func Convert_autoscaling_ContainerResourceMetricStatus_To_v2beta1_ContainerResourceMetricStatus(in *autoscaling.ContainerResourceMetricStatus, out *autoscalingv2beta1.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        out.CurrentAverageUtilization = in.Current.AverageUtilization
        if in.Current.AverageValue != nil {
                out.CurrentAverageValue = *in.Current.AverageValue
        }
        return nil
}

func Convert_v2beta1_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in *autoscalingv2beta1.ResourceMetricStatus, out *autoscaling.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        utilization := in.CurrentAverageUtilization
        averageValue := in.CurrentAverageValue
        out.Current = autoscaling.MetricValueStatus{
                AverageValue:       &averageValue,
                AverageUtilization: utilization,
        }
        return nil
}

func Convert_autoscaling_ResourceMetricStatus_To_v2beta1_ResourceMetricStatus(in *autoscaling.ResourceMetricStatus, out *autoscalingv2beta1.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.CurrentAverageUtilization = in.Current.AverageUtilization
        if in.Current.AverageValue != nil {
                out.CurrentAverageValue = *in.Current.AverageValue
        }
        return nil
}

func Convert_v2beta1_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in *autoscalingv2beta1.ResourceMetricSource, out *autoscaling.ResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        utilization := in.TargetAverageUtilization
        averageValue := in.TargetAverageValue

        var metricType autoscaling.MetricTargetType
        if utilization == nil {
                metricType = autoscaling.AverageValueMetricType
        } else {
                metricType = autoscaling.UtilizationMetricType
        }
        out.Target = autoscaling.MetricTarget{
                Type:               metricType,
                AverageValue:       averageValue,
                AverageUtilization: utilization,
        }
        return nil
}

func Convert_autoscaling_ResourceMetricSource_To_v2beta1_ResourceMetricSource(in *autoscaling.ResourceMetricSource, out *autoscalingv2beta1.ResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.TargetAverageUtilization = in.Target.AverageUtilization
        out.TargetAverageValue = in.Target.AverageValue
        return nil
}

func Convert_autoscaling_ExternalMetricSource_To_v2beta1_ExternalMetricSource(in *autoscaling.ExternalMetricSource, out *autoscalingv2beta1.ExternalMetricSource, s conversion.Scope) error {
        out.MetricName = in.Metric.Name
        out.TargetValue = in.Target.Value
        out.TargetAverageValue = in.Target.AverageValue
        out.MetricSelector = in.Metric.Selector
        return nil
}

func Convert_v2beta1_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in *autoscalingv2beta1.ExternalMetricSource, out *autoscaling.ExternalMetricSource, s conversion.Scope) error {
        value := in.TargetValue
        averageValue := in.TargetAverageValue

        var metricType autoscaling.MetricTargetType
        if value == nil {
                metricType = autoscaling.AverageValueMetricType
        } else {
                metricType = autoscaling.ValueMetricType
        }

        out.Target = autoscaling.MetricTarget{
                Type:         metricType,
                Value:        value,
                AverageValue: averageValue,
        }

        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.MetricSelector,
        }
        return nil
}

func Convert_autoscaling_ObjectMetricSource_To_v2beta1_ObjectMetricSource(in *autoscaling.ObjectMetricSource, out *autoscalingv2beta1.ObjectMetricSource, s conversion.Scope) error {
        if in.Target.Value != nil {
                out.TargetValue = *in.Target.Value
        }
        out.AverageValue = in.Target.AverageValue

        out.Target = autoscalingv2beta1.CrossVersionObjectReference{
                Kind:       in.DescribedObject.Kind,
                Name:       in.DescribedObject.Name,
                APIVersion: in.DescribedObject.APIVersion,
        }
        out.MetricName = in.Metric.Name
        out.Selector = in.Metric.Selector

        return nil
}

func Convert_v2beta1_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in *autoscalingv2beta1.ObjectMetricSource, out *autoscaling.ObjectMetricSource, s conversion.Scope) error {
        var metricType autoscaling.MetricTargetType
        if in.AverageValue == nil {
                metricType = autoscaling.ValueMetricType
        } else {
                metricType = autoscaling.AverageValueMetricType
        }
        out.Target = autoscaling.MetricTarget{
                Type:         metricType,
                Value:        &in.TargetValue,
                AverageValue: in.AverageValue,
        }
        out.DescribedObject = autoscaling.CrossVersionObjectReference{
                Kind:       in.Target.Kind,
                Name:       in.Target.Name,
                APIVersion: in.Target.APIVersion,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.Selector,
        }
        return nil
}

func Convert_autoscaling_PodsMetricSource_To_v2beta1_PodsMetricSource(in *autoscaling.PodsMetricSource, out *autoscalingv2beta1.PodsMetricSource, s conversion.Scope) error {
        if in.Target.AverageValue != nil {
                targetAverageValue := *in.Target.AverageValue
                out.TargetAverageValue = targetAverageValue
        }

        out.MetricName = in.Metric.Name
        out.Selector = in.Metric.Selector

        return nil
}

func Convert_v2beta1_PodsMetricSource_To_autoscaling_PodsMetricSource(in *autoscalingv2beta1.PodsMetricSource, out *autoscaling.PodsMetricSource, s conversion.Scope) error {
        targetAverageValue := &in.TargetAverageValue
        metricType := autoscaling.AverageValueMetricType

        out.Target = autoscaling.MetricTarget{
                Type:         metricType,
                AverageValue: targetAverageValue,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.Selector,
        }
        return nil
}

func Convert_autoscaling_ExternalMetricStatus_To_v2beta1_ExternalMetricStatus(in *autoscaling.ExternalMetricStatus, out *autoscalingv2beta1.ExternalMetricStatus, s conversion.Scope) error {
        out.CurrentAverageValue = in.Current.AverageValue
        out.MetricName = in.Metric.Name
        if in.Current.Value != nil {
                out.CurrentValue = *in.Current.Value
        }
        out.MetricSelector = in.Metric.Selector
        return nil
}

func Convert_v2beta1_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in *autoscalingv2beta1.ExternalMetricStatus, out *autoscaling.ExternalMetricStatus, s conversion.Scope) error {
        value := in.CurrentValue
        averageValue := in.CurrentAverageValue
        out.Current = autoscaling.MetricValueStatus{
                Value:        &value,
                AverageValue: averageValue,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.MetricSelector,
        }
        return nil
}

func Convert_autoscaling_ObjectMetricStatus_To_v2beta1_ObjectMetricStatus(in *autoscaling.ObjectMetricStatus, out *autoscalingv2beta1.ObjectMetricStatus, s conversion.Scope) error {
        if in.Current.Value != nil {
                out.CurrentValue = *in.Current.Value
        }
        out.Target = autoscalingv2beta1.CrossVersionObjectReference{
                Kind:       in.DescribedObject.Kind,
                Name:       in.DescribedObject.Name,
                APIVersion: in.DescribedObject.APIVersion,
        }
        out.MetricName = in.Metric.Name
        out.Selector = in.Metric.Selector
        if in.Current.AverageValue != nil {
                currentAverageValue := *in.Current.AverageValue
                out.AverageValue = &currentAverageValue
        }
        return nil
}

func Convert_v2beta1_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in *autoscalingv2beta1.ObjectMetricStatus, out *autoscaling.ObjectMetricStatus, s conversion.Scope) error {
        out.Current = autoscaling.MetricValueStatus{
                Value:        &in.CurrentValue,
                AverageValue: in.AverageValue,
        }
        out.DescribedObject = autoscaling.CrossVersionObjectReference{
                Kind:       in.Target.Kind,
                Name:       in.Target.Name,
                APIVersion: in.Target.APIVersion,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.Selector,
        }
        return nil
}

func Convert_autoscaling_PodsMetricStatus_To_v2beta1_PodsMetricStatus(in *autoscaling.PodsMetricStatus, out *autoscalingv2beta1.PodsMetricStatus, s conversion.Scope) error {
        if in.Current.AverageValue != nil {
                out.CurrentAverageValue = *in.Current.AverageValue
        }
        out.MetricName = in.Metric.Name
        out.Selector = in.Metric.Selector
        return nil
}

func Convert_v2beta1_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in *autoscalingv2beta1.PodsMetricStatus, out *autoscaling.PodsMetricStatus, s conversion.Scope) error {
        out.Current = autoscaling.MetricValueStatus{
                AverageValue: &in.CurrentAverageValue,
        }
        out.Metric = autoscaling.MetricIdentifier{
                Name:     in.MetricName,
                Selector: in.Selector,
        }
        return nil
}

func Convert_autoscaling_HorizontalPodAutoscaler_To_v2beta1_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *autoscalingv2beta1.HorizontalPodAutoscaler, s conversion.Scope) error {
        if err := autoConvert_autoscaling_HorizontalPodAutoscaler_To_v2beta1_HorizontalPodAutoscaler(in, out, s); err != nil {
                return err
        }

        // clear any pre-existing round-trip annotations to make sure the only ones set are ones we produced during conversion
        annotations, copiedAnnotations := autoscaling.DropRoundTripHorizontalPodAutoscalerAnnotations(out.Annotations)
        out.Annotations = annotations

        if in.Spec.Behavior != nil {
                // TODO: this is marshaling an internal type. Fix this without breaking backwards compatibility with n-1 API servers.
                behaviorEnc, err := json.Marshal(in.Spec.Behavior)
                if err != nil {
                        return err
                }
                // copy before mutating
                if !copiedAnnotations {
                        //nolint:ineffassign
                        copiedAnnotations = true
                        out.Annotations = autoscaling.DeepCopyStringMap(out.Annotations)
                }
                out.Annotations[autoscaling.BehaviorSpecsAnnotation] = string(behaviorEnc)
        }

        return nil
}

func Convert_v2beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *autoscalingv2beta1.HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
        if err := autoConvert_v2beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in, out, s); err != nil {
                return err
        }

        if behaviorEnc, hasBehaviors := out.Annotations[autoscaling.BehaviorSpecsAnnotation]; hasBehaviors {
                // TODO: this is unmarshaling an internal type. Fix this without breaking backwards compatibility with n-1 API servers.
                var behavior autoscaling.HorizontalPodAutoscalerBehavior
                if err := json.Unmarshal([]byte(behaviorEnc), &behavior); err == nil && behavior != (autoscaling.HorizontalPodAutoscalerBehavior{}) {
                        // only move well-formed data from annotations to fields
                        out.Spec.Behavior = &behavior
                }
        }

        // drop round-tripping annotations after converting to internal
        out.Annotations, _ = autoscaling.DropRoundTripHorizontalPodAutoscalerAnnotations(out.Annotations)

        return nil
}

func Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta1_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *autoscalingv2beta1.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta1_HorizontalPodAutoscalerSpec(in, out, s)
}

func Convert_v2beta1_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in *autoscalingv2beta1.ContainerResourceMetricSource, out *autoscaling.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        utilization := in.TargetAverageUtilization
        averageValue := in.TargetAverageValue

        var metricType autoscaling.MetricTargetType
        if utilization == nil {
                metricType = autoscaling.AverageValueMetricType
        } else {
                metricType = autoscaling.UtilizationMetricType
        }
        out.Target = autoscaling.MetricTarget{
                Type:               metricType,
                AverageValue:       averageValue,
                AverageUtilization: utilization,
        }
        return nil
}

func Convert_autoscaling_ContainerResourceMetricSource_To_v2beta1_ContainerResourceMetricSource(in *autoscaling.ContainerResourceMetricSource, out *autoscalingv2beta1.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.TargetAverageUtilization = in.Target.AverageUtilization
        out.TargetAverageValue = in.Target.AverageValue
        return nil
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v2beta1

import (
        autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1"
        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/utils/ptr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_HorizontalPodAutoscaler(obj *autoscalingv2beta1.HorizontalPodAutoscaler) {
        if obj.Spec.MinReplicas == nil {
                obj.Spec.MinReplicas = ptr.To[int32](1)
        }

        if len(obj.Spec.Metrics) == 0 {
                utilizationDefaultVal := int32(autoscaling.DefaultCPUUtilization)
                obj.Spec.Metrics = []autoscalingv2beta1.MetricSpec{
                        {
                                Type: autoscalingv2beta1.ResourceMetricSourceType,
                                Resource: &autoscalingv2beta1.ResourceMetricSource{
                                        Name:                     v1.ResourceCPU,
                                        TargetAverageUtilization: &utilizationDefaultVal,
                                },
                        },
                }
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v2beta1

import (
        autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "autoscaling"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v2beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &autoscalingv2beta1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v2beta1

import (
        unsafe "unsafe"

        autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1"
        v1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta1.CrossVersionObjectReference)(nil), (*autoscaling.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(a.(*autoscalingv2beta1.CrossVersionObjectReference), b.(*autoscaling.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.CrossVersionObjectReference)(nil), (*autoscalingv2beta1.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_CrossVersionObjectReference_To_v2beta1_CrossVersionObjectReference(a.(*autoscaling.CrossVersionObjectReference), b.(*autoscalingv2beta1.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta1.HorizontalPodAutoscalerCondition)(nil), (*autoscaling.HorizontalPodAutoscalerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(a.(*autoscalingv2beta1.HorizontalPodAutoscalerCondition), b.(*autoscaling.HorizontalPodAutoscalerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerCondition)(nil), (*autoscalingv2beta1.HorizontalPodAutoscalerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta1_HorizontalPodAutoscalerCondition(a.(*autoscaling.HorizontalPodAutoscalerCondition), b.(*autoscalingv2beta1.HorizontalPodAutoscalerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta1.HorizontalPodAutoscalerList)(nil), (*autoscaling.HorizontalPodAutoscalerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(a.(*autoscalingv2beta1.HorizontalPodAutoscalerList), b.(*autoscaling.HorizontalPodAutoscalerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerList)(nil), (*autoscalingv2beta1.HorizontalPodAutoscalerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerList_To_v2beta1_HorizontalPodAutoscalerList(a.(*autoscaling.HorizontalPodAutoscalerList), b.(*autoscalingv2beta1.HorizontalPodAutoscalerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta1.HorizontalPodAutoscalerSpec)(nil), (*autoscaling.HorizontalPodAutoscalerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(a.(*autoscalingv2beta1.HorizontalPodAutoscalerSpec), b.(*autoscaling.HorizontalPodAutoscalerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta1.HorizontalPodAutoscalerStatus)(nil), (*autoscaling.HorizontalPodAutoscalerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(a.(*autoscalingv2beta1.HorizontalPodAutoscalerStatus), b.(*autoscaling.HorizontalPodAutoscalerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerStatus)(nil), (*autoscalingv2beta1.HorizontalPodAutoscalerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta1_HorizontalPodAutoscalerStatus(a.(*autoscaling.HorizontalPodAutoscalerStatus), b.(*autoscalingv2beta1.HorizontalPodAutoscalerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta1.MetricSpec)(nil), (*autoscaling.MetricSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_MetricSpec_To_autoscaling_MetricSpec(a.(*autoscalingv2beta1.MetricSpec), b.(*autoscaling.MetricSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricSpec)(nil), (*autoscalingv2beta1.MetricSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricSpec_To_v2beta1_MetricSpec(a.(*autoscaling.MetricSpec), b.(*autoscalingv2beta1.MetricSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta1.MetricStatus)(nil), (*autoscaling.MetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_MetricStatus_To_autoscaling_MetricStatus(a.(*autoscalingv2beta1.MetricStatus), b.(*autoscaling.MetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricStatus)(nil), (*autoscalingv2beta1.MetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricStatus_To_v2beta1_MetricStatus(a.(*autoscaling.MetricStatus), b.(*autoscalingv2beta1.MetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ContainerResourceMetricSource)(nil), (*autoscalingv2beta1.ContainerResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ContainerResourceMetricSource_To_v2beta1_ContainerResourceMetricSource(a.(*autoscaling.ContainerResourceMetricSource), b.(*autoscalingv2beta1.ContainerResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ContainerResourceMetricStatus)(nil), (*autoscalingv2beta1.ContainerResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ContainerResourceMetricStatus_To_v2beta1_ContainerResourceMetricStatus(a.(*autoscaling.ContainerResourceMetricStatus), b.(*autoscalingv2beta1.ContainerResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ExternalMetricSource)(nil), (*autoscalingv2beta1.ExternalMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ExternalMetricSource_To_v2beta1_ExternalMetricSource(a.(*autoscaling.ExternalMetricSource), b.(*autoscalingv2beta1.ExternalMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ExternalMetricStatus)(nil), (*autoscalingv2beta1.ExternalMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ExternalMetricStatus_To_v2beta1_ExternalMetricStatus(a.(*autoscaling.ExternalMetricStatus), b.(*autoscalingv2beta1.ExternalMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.HorizontalPodAutoscalerSpec)(nil), (*autoscalingv2beta1.HorizontalPodAutoscalerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta1_HorizontalPodAutoscalerSpec(a.(*autoscaling.HorizontalPodAutoscalerSpec), b.(*autoscalingv2beta1.HorizontalPodAutoscalerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.HorizontalPodAutoscaler)(nil), (*autoscalingv2beta1.HorizontalPodAutoscaler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscaler_To_v2beta1_HorizontalPodAutoscaler(a.(*autoscaling.HorizontalPodAutoscaler), b.(*autoscalingv2beta1.HorizontalPodAutoscaler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.MetricTarget)(nil), (*autoscalingv2beta1.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricTarget_To_v2beta1_CrossVersionObjectReference(a.(*autoscaling.MetricTarget), b.(*autoscalingv2beta1.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ObjectMetricSource)(nil), (*autoscalingv2beta1.ObjectMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ObjectMetricSource_To_v2beta1_ObjectMetricSource(a.(*autoscaling.ObjectMetricSource), b.(*autoscalingv2beta1.ObjectMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ObjectMetricStatus)(nil), (*autoscalingv2beta1.ObjectMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ObjectMetricStatus_To_v2beta1_ObjectMetricStatus(a.(*autoscaling.ObjectMetricStatus), b.(*autoscalingv2beta1.ObjectMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.PodsMetricSource)(nil), (*autoscalingv2beta1.PodsMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_PodsMetricSource_To_v2beta1_PodsMetricSource(a.(*autoscaling.PodsMetricSource), b.(*autoscalingv2beta1.PodsMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.PodsMetricStatus)(nil), (*autoscalingv2beta1.PodsMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_PodsMetricStatus_To_v2beta1_PodsMetricStatus(a.(*autoscaling.PodsMetricStatus), b.(*autoscalingv2beta1.PodsMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ResourceMetricSource)(nil), (*autoscalingv2beta1.ResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ResourceMetricSource_To_v2beta1_ResourceMetricSource(a.(*autoscaling.ResourceMetricSource), b.(*autoscalingv2beta1.ResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ResourceMetricStatus)(nil), (*autoscalingv2beta1.ResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ResourceMetricStatus_To_v2beta1_ResourceMetricStatus(a.(*autoscaling.ResourceMetricStatus), b.(*autoscalingv2beta1.ResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.ContainerResourceMetricSource)(nil), (*autoscaling.ContainerResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(a.(*autoscalingv2beta1.ContainerResourceMetricSource), b.(*autoscaling.ContainerResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.ContainerResourceMetricStatus)(nil), (*autoscaling.ContainerResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(a.(*autoscalingv2beta1.ContainerResourceMetricStatus), b.(*autoscaling.ContainerResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.CrossVersionObjectReference)(nil), (*autoscaling.MetricTarget)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_CrossVersionObjectReference_To_autoscaling_MetricTarget(a.(*autoscalingv2beta1.CrossVersionObjectReference), b.(*autoscaling.MetricTarget), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.ExternalMetricSource)(nil), (*autoscaling.ExternalMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_ExternalMetricSource_To_autoscaling_ExternalMetricSource(a.(*autoscalingv2beta1.ExternalMetricSource), b.(*autoscaling.ExternalMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.ExternalMetricStatus)(nil), (*autoscaling.ExternalMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(a.(*autoscalingv2beta1.ExternalMetricStatus), b.(*autoscaling.ExternalMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.HorizontalPodAutoscaler)(nil), (*autoscaling.HorizontalPodAutoscaler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(a.(*autoscalingv2beta1.HorizontalPodAutoscaler), b.(*autoscaling.HorizontalPodAutoscaler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.ObjectMetricSource)(nil), (*autoscaling.ObjectMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_ObjectMetricSource_To_autoscaling_ObjectMetricSource(a.(*autoscalingv2beta1.ObjectMetricSource), b.(*autoscaling.ObjectMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.ObjectMetricStatus)(nil), (*autoscaling.ObjectMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(a.(*autoscalingv2beta1.ObjectMetricStatus), b.(*autoscaling.ObjectMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.PodsMetricSource)(nil), (*autoscaling.PodsMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_PodsMetricSource_To_autoscaling_PodsMetricSource(a.(*autoscalingv2beta1.PodsMetricSource), b.(*autoscaling.PodsMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.PodsMetricStatus)(nil), (*autoscaling.PodsMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_PodsMetricStatus_To_autoscaling_PodsMetricStatus(a.(*autoscalingv2beta1.PodsMetricStatus), b.(*autoscaling.PodsMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.ResourceMetricSource)(nil), (*autoscaling.ResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_ResourceMetricSource_To_autoscaling_ResourceMetricSource(a.(*autoscalingv2beta1.ResourceMetricSource), b.(*autoscaling.ResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta1.ResourceMetricStatus)(nil), (*autoscaling.ResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta1_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(a.(*autoscalingv2beta1.ResourceMetricStatus), b.(*autoscaling.ResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v2beta1_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in *autoscalingv2beta1.ContainerResourceMetricSource, out *autoscaling.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        // WARNING: in.TargetAverageUtilization requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetAverageValue requires manual conversion: does not exist in peer-type
        out.Container = in.Container
        return nil
}

func autoConvert_autoscaling_ContainerResourceMetricSource_To_v2beta1_ContainerResourceMetricSource(in *autoscaling.ContainerResourceMetricSource, out *autoscalingv2beta1.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in *autoscalingv2beta1.ContainerResourceMetricStatus, out *autoscaling.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        // WARNING: in.CurrentAverageUtilization requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentAverageValue requires manual conversion: does not exist in peer-type
        out.Container = in.Container
        return nil
}

func autoConvert_autoscaling_ContainerResourceMetricStatus_To_v2beta1_ContainerResourceMetricStatus(in *autoscaling.ContainerResourceMetricStatus, out *autoscalingv2beta1.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *autoscalingv2beta1.CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Name = in.Name
        out.APIVersion = in.APIVersion
        return nil
}

// Convert_v2beta1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference is an autogenerated conversion function.
func Convert_v2beta1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *autoscalingv2beta1.CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
        return autoConvert_v2beta1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in, out, s)
}

func autoConvert_autoscaling_CrossVersionObjectReference_To_v2beta1_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *autoscalingv2beta1.CrossVersionObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Name = in.Name
        out.APIVersion = in.APIVersion
        return nil
}

// Convert_autoscaling_CrossVersionObjectReference_To_v2beta1_CrossVersionObjectReference is an autogenerated conversion function.
func Convert_autoscaling_CrossVersionObjectReference_To_v2beta1_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *autoscalingv2beta1.CrossVersionObjectReference, s conversion.Scope) error {
        return autoConvert_autoscaling_CrossVersionObjectReference_To_v2beta1_CrossVersionObjectReference(in, out, s)
}

func autoConvert_v2beta1_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in *autoscalingv2beta1.ExternalMetricSource, out *autoscaling.ExternalMetricSource, s conversion.Scope) error {
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.MetricSelector requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetValue requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetAverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ExternalMetricSource_To_v2beta1_ExternalMetricSource(in *autoscaling.ExternalMetricSource, out *autoscalingv2beta1.ExternalMetricSource, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in *autoscalingv2beta1.ExternalMetricStatus, out *autoscaling.ExternalMetricStatus, s conversion.Scope) error {
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.MetricSelector requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentValue requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentAverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ExternalMetricStatus_To_v2beta1_ExternalMetricStatus(in *autoscaling.ExternalMetricStatus, out *autoscalingv2beta1.ExternalMetricStatus, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *autoscalingv2beta1.HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v2beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v2beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_autoscaling_HorizontalPodAutoscaler_To_v2beta1_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *autoscalingv2beta1.HorizontalPodAutoscaler, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta1_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta1_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v2beta1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in *autoscalingv2beta1.HorizontalPodAutoscalerCondition, out *autoscaling.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        out.Type = autoscaling.HorizontalPodAutoscalerConditionType(in.Type)
        out.Status = autoscaling.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v2beta1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition is an autogenerated conversion function.
func Convert_v2beta1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in *autoscalingv2beta1.HorizontalPodAutoscalerCondition, out *autoscaling.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        return autoConvert_v2beta1_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta1_HorizontalPodAutoscalerCondition(in *autoscaling.HorizontalPodAutoscalerCondition, out *autoscalingv2beta1.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        out.Type = autoscalingv2beta1.HorizontalPodAutoscalerConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta1_HorizontalPodAutoscalerCondition is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta1_HorizontalPodAutoscalerCondition(in *autoscaling.HorizontalPodAutoscalerCondition, out *autoscalingv2beta1.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta1_HorizontalPodAutoscalerCondition(in, out, s)
}

func autoConvert_v2beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *autoscalingv2beta1.HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]autoscaling.HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        if err := Convert_v2beta1_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v2beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList is an autogenerated conversion function.
func Convert_v2beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *autoscalingv2beta1.HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
        return autoConvert_v2beta1_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v2beta1_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *autoscalingv2beta1.HorizontalPodAutoscalerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]autoscalingv2beta1.HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_HorizontalPodAutoscaler_To_v2beta1_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerList_To_v2beta1_HorizontalPodAutoscalerList is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerList_To_v2beta1_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *autoscalingv2beta1.HorizontalPodAutoscalerList, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v2beta1_HorizontalPodAutoscalerList(in, out, s)
}

func autoConvert_v2beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *autoscalingv2beta1.HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_v2beta1_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }
        out.MinReplicas = (*int32)(unsafe.Pointer(in.MinReplicas))
        out.MaxReplicas = in.MaxReplicas
        if in.Metrics != nil {
                in, out := &in.Metrics, &out.Metrics
                *out = make([]autoscaling.MetricSpec, len(*in))
                for i := range *in {
                        if err := Convert_v2beta1_MetricSpec_To_autoscaling_MetricSpec(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Metrics = nil
        }
        return nil
}

// Convert_v2beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec is an autogenerated conversion function.
func Convert_v2beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *autoscalingv2beta1.HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        return autoConvert_v2beta1_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta1_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *autoscalingv2beta1.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v2beta1_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }
        out.MinReplicas = (*int32)(unsafe.Pointer(in.MinReplicas))
        out.MaxReplicas = in.MaxReplicas
        if in.Metrics != nil {
                in, out := &in.Metrics, &out.Metrics
                *out = make([]autoscalingv2beta1.MetricSpec, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_MetricSpec_To_v2beta1_MetricSpec(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Metrics = nil
        }
        // WARNING: in.Behavior requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *autoscalingv2beta1.HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.LastScaleTime = (*metav1.Time)(unsafe.Pointer(in.LastScaleTime))
        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas
        if in.CurrentMetrics != nil {
                in, out := &in.CurrentMetrics, &out.CurrentMetrics
                *out = make([]autoscaling.MetricStatus, len(*in))
                for i := range *in {
                        if err := Convert_v2beta1_MetricStatus_To_autoscaling_MetricStatus(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.CurrentMetrics = nil
        }
        out.Conditions = *(*[]autoscaling.HorizontalPodAutoscalerCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v2beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus is an autogenerated conversion function.
func Convert_v2beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *autoscalingv2beta1.HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        return autoConvert_v2beta1_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta1_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *autoscalingv2beta1.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.LastScaleTime = (*metav1.Time)(unsafe.Pointer(in.LastScaleTime))
        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas
        if in.CurrentMetrics != nil {
                in, out := &in.CurrentMetrics, &out.CurrentMetrics
                *out = make([]autoscalingv2beta1.MetricStatus, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_MetricStatus_To_v2beta1_MetricStatus(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.CurrentMetrics = nil
        }
        out.Conditions = *(*[]autoscalingv2beta1.HorizontalPodAutoscalerCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta1_HorizontalPodAutoscalerStatus is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta1_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *autoscalingv2beta1.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta1_HorizontalPodAutoscalerStatus(in, out, s)
}

func autoConvert_v2beta1_MetricSpec_To_autoscaling_MetricSpec(in *autoscalingv2beta1.MetricSpec, out *autoscaling.MetricSpec, s conversion.Scope) error {
        out.Type = autoscaling.MetricSourceType(in.Type)
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(autoscaling.ObjectMetricSource)
                if err := Convert_v2beta1_ObjectMetricSource_To_autoscaling_ObjectMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Object = nil
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(autoscaling.PodsMetricSource)
                if err := Convert_v2beta1_PodsMetricSource_To_autoscaling_PodsMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Pods = nil
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(autoscaling.ResourceMetricSource)
                if err := Convert_v2beta1_ResourceMetricSource_To_autoscaling_ResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Resource = nil
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscaling.ContainerResourceMetricSource)
                if err := Convert_v2beta1_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(autoscaling.ExternalMetricSource)
                if err := Convert_v2beta1_ExternalMetricSource_To_autoscaling_ExternalMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.External = nil
        }
        return nil
}

// Convert_v2beta1_MetricSpec_To_autoscaling_MetricSpec is an autogenerated conversion function.
func Convert_v2beta1_MetricSpec_To_autoscaling_MetricSpec(in *autoscalingv2beta1.MetricSpec, out *autoscaling.MetricSpec, s conversion.Scope) error {
        return autoConvert_v2beta1_MetricSpec_To_autoscaling_MetricSpec(in, out, s)
}

func autoConvert_autoscaling_MetricSpec_To_v2beta1_MetricSpec(in *autoscaling.MetricSpec, out *autoscalingv2beta1.MetricSpec, s conversion.Scope) error {
        out.Type = autoscalingv2beta1.MetricSourceType(in.Type)
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(autoscalingv2beta1.ObjectMetricSource)
                if err := Convert_autoscaling_ObjectMetricSource_To_v2beta1_ObjectMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Object = nil
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(autoscalingv2beta1.PodsMetricSource)
                if err := Convert_autoscaling_PodsMetricSource_To_v2beta1_PodsMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Pods = nil
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(autoscalingv2beta1.ResourceMetricSource)
                if err := Convert_autoscaling_ResourceMetricSource_To_v2beta1_ResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Resource = nil
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscalingv2beta1.ContainerResourceMetricSource)
                if err := Convert_autoscaling_ContainerResourceMetricSource_To_v2beta1_ContainerResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(autoscalingv2beta1.ExternalMetricSource)
                if err := Convert_autoscaling_ExternalMetricSource_To_v2beta1_ExternalMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.External = nil
        }
        return nil
}

// Convert_autoscaling_MetricSpec_To_v2beta1_MetricSpec is an autogenerated conversion function.
func Convert_autoscaling_MetricSpec_To_v2beta1_MetricSpec(in *autoscaling.MetricSpec, out *autoscalingv2beta1.MetricSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricSpec_To_v2beta1_MetricSpec(in, out, s)
}

func autoConvert_v2beta1_MetricStatus_To_autoscaling_MetricStatus(in *autoscalingv2beta1.MetricStatus, out *autoscaling.MetricStatus, s conversion.Scope) error {
        out.Type = autoscaling.MetricSourceType(in.Type)
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(autoscaling.ObjectMetricStatus)
                if err := Convert_v2beta1_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Object = nil
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(autoscaling.PodsMetricStatus)
                if err := Convert_v2beta1_PodsMetricStatus_To_autoscaling_PodsMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Pods = nil
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(autoscaling.ResourceMetricStatus)
                if err := Convert_v2beta1_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Resource = nil
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscaling.ContainerResourceMetricStatus)
                if err := Convert_v2beta1_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(autoscaling.ExternalMetricStatus)
                if err := Convert_v2beta1_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.External = nil
        }
        return nil
}

// Convert_v2beta1_MetricStatus_To_autoscaling_MetricStatus is an autogenerated conversion function.
func Convert_v2beta1_MetricStatus_To_autoscaling_MetricStatus(in *autoscalingv2beta1.MetricStatus, out *autoscaling.MetricStatus, s conversion.Scope) error {
        return autoConvert_v2beta1_MetricStatus_To_autoscaling_MetricStatus(in, out, s)
}

func autoConvert_autoscaling_MetricStatus_To_v2beta1_MetricStatus(in *autoscaling.MetricStatus, out *autoscalingv2beta1.MetricStatus, s conversion.Scope) error {
        out.Type = autoscalingv2beta1.MetricSourceType(in.Type)
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(autoscalingv2beta1.ObjectMetricStatus)
                if err := Convert_autoscaling_ObjectMetricStatus_To_v2beta1_ObjectMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Object = nil
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(autoscalingv2beta1.PodsMetricStatus)
                if err := Convert_autoscaling_PodsMetricStatus_To_v2beta1_PodsMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Pods = nil
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(autoscalingv2beta1.ResourceMetricStatus)
                if err := Convert_autoscaling_ResourceMetricStatus_To_v2beta1_ResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Resource = nil
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscalingv2beta1.ContainerResourceMetricStatus)
                if err := Convert_autoscaling_ContainerResourceMetricStatus_To_v2beta1_ContainerResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(autoscalingv2beta1.ExternalMetricStatus)
                if err := Convert_autoscaling_ExternalMetricStatus_To_v2beta1_ExternalMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.External = nil
        }
        return nil
}

// Convert_autoscaling_MetricStatus_To_v2beta1_MetricStatus is an autogenerated conversion function.
func Convert_autoscaling_MetricStatus_To_v2beta1_MetricStatus(in *autoscaling.MetricStatus, out *autoscalingv2beta1.MetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricStatus_To_v2beta1_MetricStatus(in, out, s)
}

func autoConvert_v2beta1_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in *autoscalingv2beta1.ObjectMetricSource, out *autoscaling.ObjectMetricSource, s conversion.Scope) error {
        if err := Convert_v2beta1_CrossVersionObjectReference_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetValue requires manual conversion: does not exist in peer-type
        // WARNING: in.Selector requires manual conversion: does not exist in peer-type
        // WARNING: in.AverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ObjectMetricSource_To_v2beta1_ObjectMetricSource(in *autoscaling.ObjectMetricSource, out *autoscalingv2beta1.ObjectMetricSource, s conversion.Scope) error {
        // WARNING: in.DescribedObject requires manual conversion: does not exist in peer-type
        if err := Convert_autoscaling_MetricTarget_To_v2beta1_CrossVersionObjectReference(&in.Target, &out.Target, s); err != nil {
                return err
        }
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in *autoscalingv2beta1.ObjectMetricStatus, out *autoscaling.ObjectMetricStatus, s conversion.Scope) error {
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentValue requires manual conversion: does not exist in peer-type
        // WARNING: in.Selector requires manual conversion: does not exist in peer-type
        // WARNING: in.AverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ObjectMetricStatus_To_v2beta1_ObjectMetricStatus(in *autoscaling.ObjectMetricStatus, out *autoscalingv2beta1.ObjectMetricStatus, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        // WARNING: in.DescribedObject requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_PodsMetricSource_To_autoscaling_PodsMetricSource(in *autoscalingv2beta1.PodsMetricSource, out *autoscaling.PodsMetricSource, s conversion.Scope) error {
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetAverageValue requires manual conversion: does not exist in peer-type
        // WARNING: in.Selector requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_PodsMetricSource_To_v2beta1_PodsMetricSource(in *autoscaling.PodsMetricSource, out *autoscalingv2beta1.PodsMetricSource, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in *autoscalingv2beta1.PodsMetricStatus, out *autoscaling.PodsMetricStatus, s conversion.Scope) error {
        // WARNING: in.MetricName requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentAverageValue requires manual conversion: does not exist in peer-type
        // WARNING: in.Selector requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_PodsMetricStatus_To_v2beta1_PodsMetricStatus(in *autoscaling.PodsMetricStatus, out *autoscalingv2beta1.PodsMetricStatus, s conversion.Scope) error {
        // WARNING: in.Metric requires manual conversion: does not exist in peer-type
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in *autoscalingv2beta1.ResourceMetricSource, out *autoscaling.ResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        // WARNING: in.TargetAverageUtilization requires manual conversion: does not exist in peer-type
        // WARNING: in.TargetAverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ResourceMetricSource_To_v2beta1_ResourceMetricSource(in *autoscaling.ResourceMetricSource, out *autoscalingv2beta1.ResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        // WARNING: in.Target requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta1_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in *autoscalingv2beta1.ResourceMetricStatus, out *autoscaling.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        // WARNING: in.CurrentAverageUtilization requires manual conversion: does not exist in peer-type
        // WARNING: in.CurrentAverageValue requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ResourceMetricStatus_To_v2beta1_ResourceMetricStatus(in *autoscaling.ResourceMetricStatus, out *autoscalingv2beta1.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        // WARNING: in.Current requires manual conversion: does not exist in peer-type
        return nil
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v2beta1

import (
        autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&autoscalingv2beta1.HorizontalPodAutoscaler{}, func(obj interface{}) {
                SetObjectDefaults_HorizontalPodAutoscaler(obj.(*autoscalingv2beta1.HorizontalPodAutoscaler))
        })
        scheme.AddTypeDefaultingFunc(&autoscalingv2beta1.HorizontalPodAutoscalerList{}, func(obj interface{}) {
                SetObjectDefaults_HorizontalPodAutoscalerList(obj.(*autoscalingv2beta1.HorizontalPodAutoscalerList))
        })
        return nil
}

func SetObjectDefaults_HorizontalPodAutoscaler(in *autoscalingv2beta1.HorizontalPodAutoscaler) {
        SetDefaults_HorizontalPodAutoscaler(in)
}

func SetObjectDefaults_HorizontalPodAutoscalerList(in *autoscalingv2beta1.HorizontalPodAutoscalerList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_HorizontalPodAutoscaler(a)
        }
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package v2beta2

import (
        "fmt"

        autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2"

        "k8s.io/apimachinery/pkg/api/resource"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
)

func Convert_autoscaling_HorizontalPodAutoscaler_To_v2beta2_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *autoscalingv2beta2.HorizontalPodAutoscaler, s conversion.Scope) error {
        if err := autoConvert_autoscaling_HorizontalPodAutoscaler_To_v2beta2_HorizontalPodAutoscaler(in, out, s); err != nil {
                return err
        }
        // Ensure old round-trips annotations are discarded
        annotations, copiedAnnotations := autoscaling.DropRoundTripHorizontalPodAutoscalerAnnotations(out.Annotations)
        out.Annotations = annotations

        behavior := in.Spec.Behavior
        if behavior == nil {
                return nil
        }
        // Save the tolerance fields in annotations for round-trip
        if behavior.ScaleDown != nil && behavior.ScaleDown.Tolerance != nil {
                if !copiedAnnotations {
                        copiedAnnotations = true
                        out.Annotations = autoscaling.DeepCopyStringMap(out.Annotations)
                }
                out.Annotations[autoscaling.ToleranceScaleDownAnnotation] = behavior.ScaleDown.Tolerance.String()
        }
        if behavior.ScaleUp != nil && behavior.ScaleUp.Tolerance != nil {
                if !copiedAnnotations {
                        copiedAnnotations = true //nolint:ineffassign // Intentionally setting the variable even though it's not read because this might change when adding another if clause below in the future.
                        out.Annotations = autoscaling.DeepCopyStringMap(out.Annotations)
                }
                out.Annotations[autoscaling.ToleranceScaleUpAnnotation] = behavior.ScaleUp.Tolerance.String()
        }
        return nil
}

func Convert_v2beta2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *autoscalingv2beta2.HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
        if err := autoConvert_v2beta2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in, out, s); err != nil {
                return err
        }
        // Restore the tolerance fields from annotations for round-trip
        if tolerance, ok := out.Annotations[autoscaling.ToleranceScaleDownAnnotation]; ok {
                if out.Spec.Behavior == nil {
                        out.Spec.Behavior = &autoscaling.HorizontalPodAutoscalerBehavior{}
                }
                if out.Spec.Behavior.ScaleDown == nil {
                        out.Spec.Behavior.ScaleDown = &autoscaling.HPAScalingRules{}
                }
                q, err := resource.ParseQuantity(tolerance)
                if err != nil {
                        return fmt.Errorf("failed to parse annotation %q: %w", autoscaling.ToleranceScaleDownAnnotation, err)
                }
                out.Spec.Behavior.ScaleDown.Tolerance = &q
        }
        if tolerance, ok := out.Annotations[autoscaling.ToleranceScaleUpAnnotation]; ok {
                if out.Spec.Behavior == nil {
                        out.Spec.Behavior = &autoscaling.HorizontalPodAutoscalerBehavior{}
                }
                if out.Spec.Behavior.ScaleUp == nil {
                        out.Spec.Behavior.ScaleUp = &autoscaling.HPAScalingRules{}
                }
                q, err := resource.ParseQuantity(tolerance)
                if err != nil {
                        return fmt.Errorf("failed to parse annotation %q: %w", autoscaling.ToleranceScaleUpAnnotation, err)
                }
                out.Spec.Behavior.ScaleUp.Tolerance = &q
        }
        // Do not save round-trip annotations in internal resource
        out.Annotations, _ = autoscaling.DropRoundTripHorizontalPodAutoscalerAnnotations(out.Annotations)
        return nil
}

func Convert_v2beta2_HPAScalingRules_To_autoscaling_HPAScalingRules(in *autoscalingv2beta2.HPAScalingRules, out *autoscaling.HPAScalingRules, s conversion.Scope) error {
        // Tolerance field is handled in the HorizontalPodAutoscaler conversion function.
        return autoConvert_v2beta2_HPAScalingRules_To_autoscaling_HPAScalingRules(in, out, s)
}

func Convert_autoscaling_HPAScalingRules_To_v2beta2_HPAScalingRules(in *autoscaling.HPAScalingRules, out *autoscalingv2beta2.HPAScalingRules, s conversion.Scope) error {
        // Tolerance field is handled in the HorizontalPodAutoscaler conversion function.
        return autoConvert_autoscaling_HPAScalingRules_To_v2beta2_HPAScalingRules(in, out, s)
}

/*
Copyright 2018 The Kubernetes Authors.

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.
*/

package v2beta2

import (
        autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2"
        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/utils/ptr"
)

var (
        // These constants repeats previous HPA behavior
        scaleUpLimitPercent         int32 = 100
        scaleUpLimitMinimumPods     int32 = 4
        scaleUpPeriod               int32 = 15
        scaleUpStabilizationSeconds int32
        maxPolicy                   = autoscalingv2beta2.MaxPolicySelect
        defaultHPAScaleUpRules      = autoscalingv2beta2.HPAScalingRules{
                StabilizationWindowSeconds: &scaleUpStabilizationSeconds,
                SelectPolicy:               &maxPolicy,
                Policies: []autoscalingv2beta2.HPAScalingPolicy{
                        {
                                Type:          autoscalingv2beta2.PodsScalingPolicy,
                                Value:         scaleUpLimitMinimumPods,
                                PeriodSeconds: scaleUpPeriod,
                        },
                        {
                                Type:          autoscalingv2beta2.PercentScalingPolicy,
                                Value:         scaleUpLimitPercent,
                                PeriodSeconds: scaleUpPeriod,
                        },
                },
        }
        scaleDownPeriod int32 = 15
        // Currently we can set the downscaleStabilizationWindow from the command line
        // So we can not rewrite the command line option from here
        scaleDownStabilizationSeconds *int32 = nil
        scaleDownLimitPercent         int32  = 100
        defaultHPAScaleDownRules             = autoscalingv2beta2.HPAScalingRules{
                StabilizationWindowSeconds: scaleDownStabilizationSeconds,
                SelectPolicy:               &maxPolicy,
                Policies: []autoscalingv2beta2.HPAScalingPolicy{
                        {
                                Type:          autoscalingv2beta2.PercentScalingPolicy,
                                Value:         scaleDownLimitPercent,
                                PeriodSeconds: scaleDownPeriod,
                        },
                },
        }
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_HorizontalPodAutoscaler(obj *autoscalingv2beta2.HorizontalPodAutoscaler) {
        if obj.Spec.MinReplicas == nil {
                obj.Spec.MinReplicas = ptr.To[int32](1)
        }

        if len(obj.Spec.Metrics) == 0 {
                utilizationDefaultVal := int32(autoscaling.DefaultCPUUtilization)
                obj.Spec.Metrics = []autoscalingv2beta2.MetricSpec{
                        {
                                Type: autoscalingv2beta2.ResourceMetricSourceType,
                                Resource: &autoscalingv2beta2.ResourceMetricSource{
                                        Name: v1.ResourceCPU,
                                        Target: autoscalingv2beta2.MetricTarget{
                                                Type:               autoscalingv2beta2.UtilizationMetricType,
                                                AverageUtilization: &utilizationDefaultVal,
                                        },
                                },
                        },
                }
        }
        SetDefaults_HorizontalPodAutoscalerBehavior(obj)
}

// SetDefaults_HorizontalPodAutoscalerBehavior fills the behavior if it is not null
func SetDefaults_HorizontalPodAutoscalerBehavior(obj *autoscalingv2beta2.HorizontalPodAutoscaler) {
        // if behavior is specified, we should fill all the 'nil' values with the default ones
        if obj.Spec.Behavior != nil {
                obj.Spec.Behavior.ScaleUp = GenerateHPAScaleUpRules(obj.Spec.Behavior.ScaleUp)
                obj.Spec.Behavior.ScaleDown = GenerateHPAScaleDownRules(obj.Spec.Behavior.ScaleDown)
        }
}

// GenerateHPAScaleUpRules returns a fully-initialized HPAScalingRules value
// We guarantee that no pointer in the structure will have the 'nil' value
func GenerateHPAScaleUpRules(scalingRules *autoscalingv2beta2.HPAScalingRules) *autoscalingv2beta2.HPAScalingRules {
        defaultScalingRules := defaultHPAScaleUpRules.DeepCopy()
        return copyHPAScalingRules(scalingRules, defaultScalingRules)
}

// GenerateHPAScaleDownRules returns a fully-initialized HPAScalingRules value
// We guarantee that no pointer in the structure will have the 'nil' value
// EXCEPT StabilizationWindowSeconds, for reasoning check the comment for defaultHPAScaleDownRules
func GenerateHPAScaleDownRules(scalingRules *autoscalingv2beta2.HPAScalingRules) *autoscalingv2beta2.HPAScalingRules {
        defaultScalingRules := defaultHPAScaleDownRules.DeepCopy()
        return copyHPAScalingRules(scalingRules, defaultScalingRules)
}

// copyHPAScalingRules copies all non-`nil` fields in HPA constraint structure
func copyHPAScalingRules(from, to *autoscalingv2beta2.HPAScalingRules) *autoscalingv2beta2.HPAScalingRules {
        if from == nil {
                return to
        }
        if from.SelectPolicy != nil {
                to.SelectPolicy = from.SelectPolicy
        }
        if from.StabilizationWindowSeconds != nil {
                to.StabilizationWindowSeconds = from.StabilizationWindowSeconds
        }
        if from.Policies != nil {
                to.Policies = from.Policies
        }
        return to
}

/*
Copyright 2018 The Kubernetes Authors.

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.
*/

package v2beta2

import (
        autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "autoscaling"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v2beta2"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &autoscalingv2beta2.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v2beta2

import (
        unsafe "unsafe"

        autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2"
        v1 "k8s.io/api/core/v1"
        resource "k8s.io/apimachinery/pkg/api/resource"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.ContainerResourceMetricSource)(nil), (*autoscaling.ContainerResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(a.(*autoscalingv2beta2.ContainerResourceMetricSource), b.(*autoscaling.ContainerResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ContainerResourceMetricSource)(nil), (*autoscalingv2beta2.ContainerResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ContainerResourceMetricSource_To_v2beta2_ContainerResourceMetricSource(a.(*autoscaling.ContainerResourceMetricSource), b.(*autoscalingv2beta2.ContainerResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.ContainerResourceMetricStatus)(nil), (*autoscaling.ContainerResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(a.(*autoscalingv2beta2.ContainerResourceMetricStatus), b.(*autoscaling.ContainerResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ContainerResourceMetricStatus)(nil), (*autoscalingv2beta2.ContainerResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ContainerResourceMetricStatus_To_v2beta2_ContainerResourceMetricStatus(a.(*autoscaling.ContainerResourceMetricStatus), b.(*autoscalingv2beta2.ContainerResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.CrossVersionObjectReference)(nil), (*autoscaling.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(a.(*autoscalingv2beta2.CrossVersionObjectReference), b.(*autoscaling.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.CrossVersionObjectReference)(nil), (*autoscalingv2beta2.CrossVersionObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_CrossVersionObjectReference_To_v2beta2_CrossVersionObjectReference(a.(*autoscaling.CrossVersionObjectReference), b.(*autoscalingv2beta2.CrossVersionObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.ExternalMetricSource)(nil), (*autoscaling.ExternalMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_ExternalMetricSource_To_autoscaling_ExternalMetricSource(a.(*autoscalingv2beta2.ExternalMetricSource), b.(*autoscaling.ExternalMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ExternalMetricSource)(nil), (*autoscalingv2beta2.ExternalMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ExternalMetricSource_To_v2beta2_ExternalMetricSource(a.(*autoscaling.ExternalMetricSource), b.(*autoscalingv2beta2.ExternalMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.ExternalMetricStatus)(nil), (*autoscaling.ExternalMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(a.(*autoscalingv2beta2.ExternalMetricStatus), b.(*autoscaling.ExternalMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ExternalMetricStatus)(nil), (*autoscalingv2beta2.ExternalMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ExternalMetricStatus_To_v2beta2_ExternalMetricStatus(a.(*autoscaling.ExternalMetricStatus), b.(*autoscalingv2beta2.ExternalMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.HPAScalingPolicy)(nil), (*autoscaling.HPAScalingPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy(a.(*autoscalingv2beta2.HPAScalingPolicy), b.(*autoscaling.HPAScalingPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HPAScalingPolicy)(nil), (*autoscalingv2beta2.HPAScalingPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HPAScalingPolicy_To_v2beta2_HPAScalingPolicy(a.(*autoscaling.HPAScalingPolicy), b.(*autoscalingv2beta2.HPAScalingPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.HorizontalPodAutoscalerBehavior)(nil), (*autoscaling.HorizontalPodAutoscalerBehavior)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(a.(*autoscalingv2beta2.HorizontalPodAutoscalerBehavior), b.(*autoscaling.HorizontalPodAutoscalerBehavior), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerBehavior)(nil), (*autoscalingv2beta2.HorizontalPodAutoscalerBehavior)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2beta2_HorizontalPodAutoscalerBehavior(a.(*autoscaling.HorizontalPodAutoscalerBehavior), b.(*autoscalingv2beta2.HorizontalPodAutoscalerBehavior), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.HorizontalPodAutoscalerCondition)(nil), (*autoscaling.HorizontalPodAutoscalerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(a.(*autoscalingv2beta2.HorizontalPodAutoscalerCondition), b.(*autoscaling.HorizontalPodAutoscalerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerCondition)(nil), (*autoscalingv2beta2.HorizontalPodAutoscalerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta2_HorizontalPodAutoscalerCondition(a.(*autoscaling.HorizontalPodAutoscalerCondition), b.(*autoscalingv2beta2.HorizontalPodAutoscalerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.HorizontalPodAutoscalerList)(nil), (*autoscaling.HorizontalPodAutoscalerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(a.(*autoscalingv2beta2.HorizontalPodAutoscalerList), b.(*autoscaling.HorizontalPodAutoscalerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerList)(nil), (*autoscalingv2beta2.HorizontalPodAutoscalerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerList_To_v2beta2_HorizontalPodAutoscalerList(a.(*autoscaling.HorizontalPodAutoscalerList), b.(*autoscalingv2beta2.HorizontalPodAutoscalerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.HorizontalPodAutoscalerSpec)(nil), (*autoscaling.HorizontalPodAutoscalerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(a.(*autoscalingv2beta2.HorizontalPodAutoscalerSpec), b.(*autoscaling.HorizontalPodAutoscalerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerSpec)(nil), (*autoscalingv2beta2.HorizontalPodAutoscalerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta2_HorizontalPodAutoscalerSpec(a.(*autoscaling.HorizontalPodAutoscalerSpec), b.(*autoscalingv2beta2.HorizontalPodAutoscalerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.HorizontalPodAutoscalerStatus)(nil), (*autoscaling.HorizontalPodAutoscalerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(a.(*autoscalingv2beta2.HorizontalPodAutoscalerStatus), b.(*autoscaling.HorizontalPodAutoscalerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.HorizontalPodAutoscalerStatus)(nil), (*autoscalingv2beta2.HorizontalPodAutoscalerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta2_HorizontalPodAutoscalerStatus(a.(*autoscaling.HorizontalPodAutoscalerStatus), b.(*autoscalingv2beta2.HorizontalPodAutoscalerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.MetricIdentifier)(nil), (*autoscaling.MetricIdentifier)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(a.(*autoscalingv2beta2.MetricIdentifier), b.(*autoscaling.MetricIdentifier), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricIdentifier)(nil), (*autoscalingv2beta2.MetricIdentifier)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(a.(*autoscaling.MetricIdentifier), b.(*autoscalingv2beta2.MetricIdentifier), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.MetricSpec)(nil), (*autoscaling.MetricSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_MetricSpec_To_autoscaling_MetricSpec(a.(*autoscalingv2beta2.MetricSpec), b.(*autoscaling.MetricSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricSpec)(nil), (*autoscalingv2beta2.MetricSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricSpec_To_v2beta2_MetricSpec(a.(*autoscaling.MetricSpec), b.(*autoscalingv2beta2.MetricSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.MetricStatus)(nil), (*autoscaling.MetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_MetricStatus_To_autoscaling_MetricStatus(a.(*autoscalingv2beta2.MetricStatus), b.(*autoscaling.MetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricStatus)(nil), (*autoscalingv2beta2.MetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricStatus_To_v2beta2_MetricStatus(a.(*autoscaling.MetricStatus), b.(*autoscalingv2beta2.MetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.MetricTarget)(nil), (*autoscaling.MetricTarget)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(a.(*autoscalingv2beta2.MetricTarget), b.(*autoscaling.MetricTarget), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricTarget)(nil), (*autoscalingv2beta2.MetricTarget)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(a.(*autoscaling.MetricTarget), b.(*autoscalingv2beta2.MetricTarget), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.MetricValueStatus)(nil), (*autoscaling.MetricValueStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(a.(*autoscalingv2beta2.MetricValueStatus), b.(*autoscaling.MetricValueStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.MetricValueStatus)(nil), (*autoscalingv2beta2.MetricValueStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(a.(*autoscaling.MetricValueStatus), b.(*autoscalingv2beta2.MetricValueStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.ObjectMetricSource)(nil), (*autoscaling.ObjectMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_ObjectMetricSource_To_autoscaling_ObjectMetricSource(a.(*autoscalingv2beta2.ObjectMetricSource), b.(*autoscaling.ObjectMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ObjectMetricSource)(nil), (*autoscalingv2beta2.ObjectMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ObjectMetricSource_To_v2beta2_ObjectMetricSource(a.(*autoscaling.ObjectMetricSource), b.(*autoscalingv2beta2.ObjectMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.ObjectMetricStatus)(nil), (*autoscaling.ObjectMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(a.(*autoscalingv2beta2.ObjectMetricStatus), b.(*autoscaling.ObjectMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ObjectMetricStatus)(nil), (*autoscalingv2beta2.ObjectMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ObjectMetricStatus_To_v2beta2_ObjectMetricStatus(a.(*autoscaling.ObjectMetricStatus), b.(*autoscalingv2beta2.ObjectMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.PodsMetricSource)(nil), (*autoscaling.PodsMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_PodsMetricSource_To_autoscaling_PodsMetricSource(a.(*autoscalingv2beta2.PodsMetricSource), b.(*autoscaling.PodsMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.PodsMetricSource)(nil), (*autoscalingv2beta2.PodsMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_PodsMetricSource_To_v2beta2_PodsMetricSource(a.(*autoscaling.PodsMetricSource), b.(*autoscalingv2beta2.PodsMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.PodsMetricStatus)(nil), (*autoscaling.PodsMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_PodsMetricStatus_To_autoscaling_PodsMetricStatus(a.(*autoscalingv2beta2.PodsMetricStatus), b.(*autoscaling.PodsMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.PodsMetricStatus)(nil), (*autoscalingv2beta2.PodsMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_PodsMetricStatus_To_v2beta2_PodsMetricStatus(a.(*autoscaling.PodsMetricStatus), b.(*autoscalingv2beta2.PodsMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.ResourceMetricSource)(nil), (*autoscaling.ResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_ResourceMetricSource_To_autoscaling_ResourceMetricSource(a.(*autoscalingv2beta2.ResourceMetricSource), b.(*autoscaling.ResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ResourceMetricSource)(nil), (*autoscalingv2beta2.ResourceMetricSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ResourceMetricSource_To_v2beta2_ResourceMetricSource(a.(*autoscaling.ResourceMetricSource), b.(*autoscalingv2beta2.ResourceMetricSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscalingv2beta2.ResourceMetricStatus)(nil), (*autoscaling.ResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(a.(*autoscalingv2beta2.ResourceMetricStatus), b.(*autoscaling.ResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ResourceMetricStatus)(nil), (*autoscalingv2beta2.ResourceMetricStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ResourceMetricStatus_To_v2beta2_ResourceMetricStatus(a.(*autoscaling.ResourceMetricStatus), b.(*autoscalingv2beta2.ResourceMetricStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.HPAScalingRules)(nil), (*autoscalingv2beta2.HPAScalingRules)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HPAScalingRules_To_v2beta2_HPAScalingRules(a.(*autoscaling.HPAScalingRules), b.(*autoscalingv2beta2.HPAScalingRules), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.HorizontalPodAutoscaler)(nil), (*autoscalingv2beta2.HorizontalPodAutoscaler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_HorizontalPodAutoscaler_To_v2beta2_HorizontalPodAutoscaler(a.(*autoscaling.HorizontalPodAutoscaler), b.(*autoscalingv2beta2.HorizontalPodAutoscaler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta2.HPAScalingRules)(nil), (*autoscaling.HPAScalingRules)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_HPAScalingRules_To_autoscaling_HPAScalingRules(a.(*autoscalingv2beta2.HPAScalingRules), b.(*autoscaling.HPAScalingRules), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscalingv2beta2.HorizontalPodAutoscaler)(nil), (*autoscaling.HorizontalPodAutoscaler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v2beta2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(a.(*autoscalingv2beta2.HorizontalPodAutoscaler), b.(*autoscaling.HorizontalPodAutoscaler), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v2beta2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in *autoscalingv2beta2.ContainerResourceMetricSource, out *autoscaling.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        if err := Convert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        out.Container = in.Container
        return nil
}

// Convert_v2beta2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource is an autogenerated conversion function.
func Convert_v2beta2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in *autoscalingv2beta2.ContainerResourceMetricSource, out *autoscaling.ContainerResourceMetricSource, s conversion.Scope) error {
        return autoConvert_v2beta2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(in, out, s)
}

func autoConvert_autoscaling_ContainerResourceMetricSource_To_v2beta2_ContainerResourceMetricSource(in *autoscaling.ContainerResourceMetricSource, out *autoscalingv2beta2.ContainerResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        if err := Convert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ContainerResourceMetricSource_To_v2beta2_ContainerResourceMetricSource is an autogenerated conversion function.
func Convert_autoscaling_ContainerResourceMetricSource_To_v2beta2_ContainerResourceMetricSource(in *autoscaling.ContainerResourceMetricSource, out *autoscalingv2beta2.ContainerResourceMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_ContainerResourceMetricSource_To_v2beta2_ContainerResourceMetricSource(in, out, s)
}

func autoConvert_v2beta2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in *autoscalingv2beta2.ContainerResourceMetricStatus, out *autoscaling.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        if err := Convert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        out.Container = in.Container
        return nil
}

// Convert_v2beta2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus is an autogenerated conversion function.
func Convert_v2beta2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in *autoscalingv2beta2.ContainerResourceMetricStatus, out *autoscaling.ContainerResourceMetricStatus, s conversion.Scope) error {
        return autoConvert_v2beta2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(in, out, s)
}

func autoConvert_autoscaling_ContainerResourceMetricStatus_To_v2beta2_ContainerResourceMetricStatus(in *autoscaling.ContainerResourceMetricStatus, out *autoscalingv2beta2.ContainerResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        out.Container = in.Container
        if err := Convert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ContainerResourceMetricStatus_To_v2beta2_ContainerResourceMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_ContainerResourceMetricStatus_To_v2beta2_ContainerResourceMetricStatus(in *autoscaling.ContainerResourceMetricStatus, out *autoscalingv2beta2.ContainerResourceMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ContainerResourceMetricStatus_To_v2beta2_ContainerResourceMetricStatus(in, out, s)
}

func autoConvert_v2beta2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *autoscalingv2beta2.CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Name = in.Name
        out.APIVersion = in.APIVersion
        return nil
}

// Convert_v2beta2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference is an autogenerated conversion function.
func Convert_v2beta2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in *autoscalingv2beta2.CrossVersionObjectReference, out *autoscaling.CrossVersionObjectReference, s conversion.Scope) error {
        return autoConvert_v2beta2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(in, out, s)
}

func autoConvert_autoscaling_CrossVersionObjectReference_To_v2beta2_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *autoscalingv2beta2.CrossVersionObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Name = in.Name
        out.APIVersion = in.APIVersion
        return nil
}

// Convert_autoscaling_CrossVersionObjectReference_To_v2beta2_CrossVersionObjectReference is an autogenerated conversion function.
func Convert_autoscaling_CrossVersionObjectReference_To_v2beta2_CrossVersionObjectReference(in *autoscaling.CrossVersionObjectReference, out *autoscalingv2beta2.CrossVersionObjectReference, s conversion.Scope) error {
        return autoConvert_autoscaling_CrossVersionObjectReference_To_v2beta2_CrossVersionObjectReference(in, out, s)
}

func autoConvert_v2beta2_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in *autoscalingv2beta2.ExternalMetricSource, out *autoscaling.ExternalMetricSource, s conversion.Scope) error {
        if err := Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2beta2_ExternalMetricSource_To_autoscaling_ExternalMetricSource is an autogenerated conversion function.
func Convert_v2beta2_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in *autoscalingv2beta2.ExternalMetricSource, out *autoscaling.ExternalMetricSource, s conversion.Scope) error {
        return autoConvert_v2beta2_ExternalMetricSource_To_autoscaling_ExternalMetricSource(in, out, s)
}

func autoConvert_autoscaling_ExternalMetricSource_To_v2beta2_ExternalMetricSource(in *autoscaling.ExternalMetricSource, out *autoscalingv2beta2.ExternalMetricSource, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ExternalMetricSource_To_v2beta2_ExternalMetricSource is an autogenerated conversion function.
func Convert_autoscaling_ExternalMetricSource_To_v2beta2_ExternalMetricSource(in *autoscaling.ExternalMetricSource, out *autoscalingv2beta2.ExternalMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_ExternalMetricSource_To_v2beta2_ExternalMetricSource(in, out, s)
}

func autoConvert_v2beta2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in *autoscalingv2beta2.ExternalMetricStatus, out *autoscaling.ExternalMetricStatus, s conversion.Scope) error {
        if err := Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2beta2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus is an autogenerated conversion function.
func Convert_v2beta2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in *autoscalingv2beta2.ExternalMetricStatus, out *autoscaling.ExternalMetricStatus, s conversion.Scope) error {
        return autoConvert_v2beta2_ExternalMetricStatus_To_autoscaling_ExternalMetricStatus(in, out, s)
}

func autoConvert_autoscaling_ExternalMetricStatus_To_v2beta2_ExternalMetricStatus(in *autoscaling.ExternalMetricStatus, out *autoscalingv2beta2.ExternalMetricStatus, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ExternalMetricStatus_To_v2beta2_ExternalMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_ExternalMetricStatus_To_v2beta2_ExternalMetricStatus(in *autoscaling.ExternalMetricStatus, out *autoscalingv2beta2.ExternalMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ExternalMetricStatus_To_v2beta2_ExternalMetricStatus(in, out, s)
}

func autoConvert_v2beta2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy(in *autoscalingv2beta2.HPAScalingPolicy, out *autoscaling.HPAScalingPolicy, s conversion.Scope) error {
        out.Type = autoscaling.HPAScalingPolicyType(in.Type)
        out.Value = in.Value
        out.PeriodSeconds = in.PeriodSeconds
        return nil
}

// Convert_v2beta2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy is an autogenerated conversion function.
func Convert_v2beta2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy(in *autoscalingv2beta2.HPAScalingPolicy, out *autoscaling.HPAScalingPolicy, s conversion.Scope) error {
        return autoConvert_v2beta2_HPAScalingPolicy_To_autoscaling_HPAScalingPolicy(in, out, s)
}

func autoConvert_autoscaling_HPAScalingPolicy_To_v2beta2_HPAScalingPolicy(in *autoscaling.HPAScalingPolicy, out *autoscalingv2beta2.HPAScalingPolicy, s conversion.Scope) error {
        out.Type = autoscalingv2beta2.HPAScalingPolicyType(in.Type)
        out.Value = in.Value
        out.PeriodSeconds = in.PeriodSeconds
        return nil
}

// Convert_autoscaling_HPAScalingPolicy_To_v2beta2_HPAScalingPolicy is an autogenerated conversion function.
func Convert_autoscaling_HPAScalingPolicy_To_v2beta2_HPAScalingPolicy(in *autoscaling.HPAScalingPolicy, out *autoscalingv2beta2.HPAScalingPolicy, s conversion.Scope) error {
        return autoConvert_autoscaling_HPAScalingPolicy_To_v2beta2_HPAScalingPolicy(in, out, s)
}

func autoConvert_v2beta2_HPAScalingRules_To_autoscaling_HPAScalingRules(in *autoscalingv2beta2.HPAScalingRules, out *autoscaling.HPAScalingRules, s conversion.Scope) error {
        out.StabilizationWindowSeconds = (*int32)(unsafe.Pointer(in.StabilizationWindowSeconds))
        out.SelectPolicy = (*autoscaling.ScalingPolicySelect)(unsafe.Pointer(in.SelectPolicy))
        out.Policies = *(*[]autoscaling.HPAScalingPolicy)(unsafe.Pointer(&in.Policies))
        return nil
}

func autoConvert_autoscaling_HPAScalingRules_To_v2beta2_HPAScalingRules(in *autoscaling.HPAScalingRules, out *autoscalingv2beta2.HPAScalingRules, s conversion.Scope) error {
        out.StabilizationWindowSeconds = (*int32)(unsafe.Pointer(in.StabilizationWindowSeconds))
        out.SelectPolicy = (*autoscalingv2beta2.ScalingPolicySelect)(unsafe.Pointer(in.SelectPolicy))
        out.Policies = *(*[]autoscalingv2beta2.HPAScalingPolicy)(unsafe.Pointer(&in.Policies))
        // WARNING: in.Tolerance requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_v2beta2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(in *autoscalingv2beta2.HorizontalPodAutoscaler, out *autoscaling.HorizontalPodAutoscaler, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v2beta2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_autoscaling_HorizontalPodAutoscaler_To_v2beta2_HorizontalPodAutoscaler(in *autoscaling.HorizontalPodAutoscaler, out *autoscalingv2beta2.HorizontalPodAutoscaler, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta2_HorizontalPodAutoscalerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta2_HorizontalPodAutoscalerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v2beta2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(in *autoscalingv2beta2.HorizontalPodAutoscalerBehavior, out *autoscaling.HorizontalPodAutoscalerBehavior, s conversion.Scope) error {
        if in.ScaleUp != nil {
                in, out := &in.ScaleUp, &out.ScaleUp
                *out = new(autoscaling.HPAScalingRules)
                if err := Convert_v2beta2_HPAScalingRules_To_autoscaling_HPAScalingRules(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ScaleUp = nil
        }
        if in.ScaleDown != nil {
                in, out := &in.ScaleDown, &out.ScaleDown
                *out = new(autoscaling.HPAScalingRules)
                if err := Convert_v2beta2_HPAScalingRules_To_autoscaling_HPAScalingRules(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ScaleDown = nil
        }
        return nil
}

// Convert_v2beta2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior is an autogenerated conversion function.
func Convert_v2beta2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(in *autoscalingv2beta2.HorizontalPodAutoscalerBehavior, out *autoscaling.HorizontalPodAutoscalerBehavior, s conversion.Scope) error {
        return autoConvert_v2beta2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2beta2_HorizontalPodAutoscalerBehavior(in *autoscaling.HorizontalPodAutoscalerBehavior, out *autoscalingv2beta2.HorizontalPodAutoscalerBehavior, s conversion.Scope) error {
        if in.ScaleUp != nil {
                in, out := &in.ScaleUp, &out.ScaleUp
                *out = new(autoscalingv2beta2.HPAScalingRules)
                if err := Convert_autoscaling_HPAScalingRules_To_v2beta2_HPAScalingRules(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ScaleUp = nil
        }
        if in.ScaleDown != nil {
                in, out := &in.ScaleDown, &out.ScaleDown
                *out = new(autoscalingv2beta2.HPAScalingRules)
                if err := Convert_autoscaling_HPAScalingRules_To_v2beta2_HPAScalingRules(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ScaleDown = nil
        }
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2beta2_HorizontalPodAutoscalerBehavior is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2beta2_HorizontalPodAutoscalerBehavior(in *autoscaling.HorizontalPodAutoscalerBehavior, out *autoscalingv2beta2.HorizontalPodAutoscalerBehavior, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2beta2_HorizontalPodAutoscalerBehavior(in, out, s)
}

func autoConvert_v2beta2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in *autoscalingv2beta2.HorizontalPodAutoscalerCondition, out *autoscaling.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        out.Type = autoscaling.HorizontalPodAutoscalerConditionType(in.Type)
        out.Status = autoscaling.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v2beta2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition is an autogenerated conversion function.
func Convert_v2beta2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in *autoscalingv2beta2.HorizontalPodAutoscalerCondition, out *autoscaling.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        return autoConvert_v2beta2_HorizontalPodAutoscalerCondition_To_autoscaling_HorizontalPodAutoscalerCondition(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta2_HorizontalPodAutoscalerCondition(in *autoscaling.HorizontalPodAutoscalerCondition, out *autoscalingv2beta2.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        out.Type = autoscalingv2beta2.HorizontalPodAutoscalerConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta2_HorizontalPodAutoscalerCondition is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta2_HorizontalPodAutoscalerCondition(in *autoscaling.HorizontalPodAutoscalerCondition, out *autoscalingv2beta2.HorizontalPodAutoscalerCondition, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerCondition_To_v2beta2_HorizontalPodAutoscalerCondition(in, out, s)
}

func autoConvert_v2beta2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *autoscalingv2beta2.HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]autoscaling.HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        if err := Convert_v2beta2_HorizontalPodAutoscaler_To_autoscaling_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v2beta2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList is an autogenerated conversion function.
func Convert_v2beta2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in *autoscalingv2beta2.HorizontalPodAutoscalerList, out *autoscaling.HorizontalPodAutoscalerList, s conversion.Scope) error {
        return autoConvert_v2beta2_HorizontalPodAutoscalerList_To_autoscaling_HorizontalPodAutoscalerList(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v2beta2_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *autoscalingv2beta2.HorizontalPodAutoscalerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]autoscalingv2beta2.HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_HorizontalPodAutoscaler_To_v2beta2_HorizontalPodAutoscaler(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerList_To_v2beta2_HorizontalPodAutoscalerList is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerList_To_v2beta2_HorizontalPodAutoscalerList(in *autoscaling.HorizontalPodAutoscalerList, out *autoscalingv2beta2.HorizontalPodAutoscalerList, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerList_To_v2beta2_HorizontalPodAutoscalerList(in, out, s)
}

func autoConvert_v2beta2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *autoscalingv2beta2.HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_v2beta2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }
        out.MinReplicas = (*int32)(unsafe.Pointer(in.MinReplicas))
        out.MaxReplicas = in.MaxReplicas
        if in.Metrics != nil {
                in, out := &in.Metrics, &out.Metrics
                *out = make([]autoscaling.MetricSpec, len(*in))
                for i := range *in {
                        if err := Convert_v2beta2_MetricSpec_To_autoscaling_MetricSpec(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Metrics = nil
        }
        if in.Behavior != nil {
                in, out := &in.Behavior, &out.Behavior
                *out = new(autoscaling.HorizontalPodAutoscalerBehavior)
                if err := Convert_v2beta2_HorizontalPodAutoscalerBehavior_To_autoscaling_HorizontalPodAutoscalerBehavior(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Behavior = nil
        }
        return nil
}

// Convert_v2beta2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec is an autogenerated conversion function.
func Convert_v2beta2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in *autoscalingv2beta2.HorizontalPodAutoscalerSpec, out *autoscaling.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        return autoConvert_v2beta2_HorizontalPodAutoscalerSpec_To_autoscaling_HorizontalPodAutoscalerSpec(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta2_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *autoscalingv2beta2.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v2beta2_CrossVersionObjectReference(&in.ScaleTargetRef, &out.ScaleTargetRef, s); err != nil {
                return err
        }
        out.MinReplicas = (*int32)(unsafe.Pointer(in.MinReplicas))
        out.MaxReplicas = in.MaxReplicas
        if in.Metrics != nil {
                in, out := &in.Metrics, &out.Metrics
                *out = make([]autoscalingv2beta2.MetricSpec, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_MetricSpec_To_v2beta2_MetricSpec(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Metrics = nil
        }
        if in.Behavior != nil {
                in, out := &in.Behavior, &out.Behavior
                *out = new(autoscalingv2beta2.HorizontalPodAutoscalerBehavior)
                if err := Convert_autoscaling_HorizontalPodAutoscalerBehavior_To_v2beta2_HorizontalPodAutoscalerBehavior(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Behavior = nil
        }
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta2_HorizontalPodAutoscalerSpec is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta2_HorizontalPodAutoscalerSpec(in *autoscaling.HorizontalPodAutoscalerSpec, out *autoscalingv2beta2.HorizontalPodAutoscalerSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerSpec_To_v2beta2_HorizontalPodAutoscalerSpec(in, out, s)
}

func autoConvert_v2beta2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *autoscalingv2beta2.HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.LastScaleTime = (*metav1.Time)(unsafe.Pointer(in.LastScaleTime))
        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas
        if in.CurrentMetrics != nil {
                in, out := &in.CurrentMetrics, &out.CurrentMetrics
                *out = make([]autoscaling.MetricStatus, len(*in))
                for i := range *in {
                        if err := Convert_v2beta2_MetricStatus_To_autoscaling_MetricStatus(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.CurrentMetrics = nil
        }
        out.Conditions = *(*[]autoscaling.HorizontalPodAutoscalerCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v2beta2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus is an autogenerated conversion function.
func Convert_v2beta2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in *autoscalingv2beta2.HorizontalPodAutoscalerStatus, out *autoscaling.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        return autoConvert_v2beta2_HorizontalPodAutoscalerStatus_To_autoscaling_HorizontalPodAutoscalerStatus(in, out, s)
}

func autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta2_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *autoscalingv2beta2.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        out.ObservedGeneration = (*int64)(unsafe.Pointer(in.ObservedGeneration))
        out.LastScaleTime = (*metav1.Time)(unsafe.Pointer(in.LastScaleTime))
        out.CurrentReplicas = in.CurrentReplicas
        out.DesiredReplicas = in.DesiredReplicas
        if in.CurrentMetrics != nil {
                in, out := &in.CurrentMetrics, &out.CurrentMetrics
                *out = make([]autoscalingv2beta2.MetricStatus, len(*in))
                for i := range *in {
                        if err := Convert_autoscaling_MetricStatus_To_v2beta2_MetricStatus(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.CurrentMetrics = nil
        }
        out.Conditions = *(*[]autoscalingv2beta2.HorizontalPodAutoscalerCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta2_HorizontalPodAutoscalerStatus is an autogenerated conversion function.
func Convert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta2_HorizontalPodAutoscalerStatus(in *autoscaling.HorizontalPodAutoscalerStatus, out *autoscalingv2beta2.HorizontalPodAutoscalerStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_HorizontalPodAutoscalerStatus_To_v2beta2_HorizontalPodAutoscalerStatus(in, out, s)
}

func autoConvert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(in *autoscalingv2beta2.MetricIdentifier, out *autoscaling.MetricIdentifier, s conversion.Scope) error {
        out.Name = in.Name
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        return nil
}

// Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier is an autogenerated conversion function.
func Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(in *autoscalingv2beta2.MetricIdentifier, out *autoscaling.MetricIdentifier, s conversion.Scope) error {
        return autoConvert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(in, out, s)
}

func autoConvert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(in *autoscaling.MetricIdentifier, out *autoscalingv2beta2.MetricIdentifier, s conversion.Scope) error {
        out.Name = in.Name
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        return nil
}

// Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier is an autogenerated conversion function.
func Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(in *autoscaling.MetricIdentifier, out *autoscalingv2beta2.MetricIdentifier, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(in, out, s)
}

func autoConvert_v2beta2_MetricSpec_To_autoscaling_MetricSpec(in *autoscalingv2beta2.MetricSpec, out *autoscaling.MetricSpec, s conversion.Scope) error {
        out.Type = autoscaling.MetricSourceType(in.Type)
        out.Object = (*autoscaling.ObjectMetricSource)(unsafe.Pointer(in.Object))
        out.Pods = (*autoscaling.PodsMetricSource)(unsafe.Pointer(in.Pods))
        out.Resource = (*autoscaling.ResourceMetricSource)(unsafe.Pointer(in.Resource))
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscaling.ContainerResourceMetricSource)
                if err := Convert_v2beta2_ContainerResourceMetricSource_To_autoscaling_ContainerResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        out.External = (*autoscaling.ExternalMetricSource)(unsafe.Pointer(in.External))
        return nil
}

// Convert_v2beta2_MetricSpec_To_autoscaling_MetricSpec is an autogenerated conversion function.
func Convert_v2beta2_MetricSpec_To_autoscaling_MetricSpec(in *autoscalingv2beta2.MetricSpec, out *autoscaling.MetricSpec, s conversion.Scope) error {
        return autoConvert_v2beta2_MetricSpec_To_autoscaling_MetricSpec(in, out, s)
}

func autoConvert_autoscaling_MetricSpec_To_v2beta2_MetricSpec(in *autoscaling.MetricSpec, out *autoscalingv2beta2.MetricSpec, s conversion.Scope) error {
        out.Type = autoscalingv2beta2.MetricSourceType(in.Type)
        out.Object = (*autoscalingv2beta2.ObjectMetricSource)(unsafe.Pointer(in.Object))
        out.Pods = (*autoscalingv2beta2.PodsMetricSource)(unsafe.Pointer(in.Pods))
        out.Resource = (*autoscalingv2beta2.ResourceMetricSource)(unsafe.Pointer(in.Resource))
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscalingv2beta2.ContainerResourceMetricSource)
                if err := Convert_autoscaling_ContainerResourceMetricSource_To_v2beta2_ContainerResourceMetricSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        out.External = (*autoscalingv2beta2.ExternalMetricSource)(unsafe.Pointer(in.External))
        return nil
}

// Convert_autoscaling_MetricSpec_To_v2beta2_MetricSpec is an autogenerated conversion function.
func Convert_autoscaling_MetricSpec_To_v2beta2_MetricSpec(in *autoscaling.MetricSpec, out *autoscalingv2beta2.MetricSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricSpec_To_v2beta2_MetricSpec(in, out, s)
}

func autoConvert_v2beta2_MetricStatus_To_autoscaling_MetricStatus(in *autoscalingv2beta2.MetricStatus, out *autoscaling.MetricStatus, s conversion.Scope) error {
        out.Type = autoscaling.MetricSourceType(in.Type)
        out.Object = (*autoscaling.ObjectMetricStatus)(unsafe.Pointer(in.Object))
        out.Pods = (*autoscaling.PodsMetricStatus)(unsafe.Pointer(in.Pods))
        out.Resource = (*autoscaling.ResourceMetricStatus)(unsafe.Pointer(in.Resource))
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscaling.ContainerResourceMetricStatus)
                if err := Convert_v2beta2_ContainerResourceMetricStatus_To_autoscaling_ContainerResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        out.External = (*autoscaling.ExternalMetricStatus)(unsafe.Pointer(in.External))
        return nil
}

// Convert_v2beta2_MetricStatus_To_autoscaling_MetricStatus is an autogenerated conversion function.
func Convert_v2beta2_MetricStatus_To_autoscaling_MetricStatus(in *autoscalingv2beta2.MetricStatus, out *autoscaling.MetricStatus, s conversion.Scope) error {
        return autoConvert_v2beta2_MetricStatus_To_autoscaling_MetricStatus(in, out, s)
}

func autoConvert_autoscaling_MetricStatus_To_v2beta2_MetricStatus(in *autoscaling.MetricStatus, out *autoscalingv2beta2.MetricStatus, s conversion.Scope) error {
        out.Type = autoscalingv2beta2.MetricSourceType(in.Type)
        out.Object = (*autoscalingv2beta2.ObjectMetricStatus)(unsafe.Pointer(in.Object))
        out.Pods = (*autoscalingv2beta2.PodsMetricStatus)(unsafe.Pointer(in.Pods))
        out.Resource = (*autoscalingv2beta2.ResourceMetricStatus)(unsafe.Pointer(in.Resource))
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(autoscalingv2beta2.ContainerResourceMetricStatus)
                if err := Convert_autoscaling_ContainerResourceMetricStatus_To_v2beta2_ContainerResourceMetricStatus(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ContainerResource = nil
        }
        out.External = (*autoscalingv2beta2.ExternalMetricStatus)(unsafe.Pointer(in.External))
        return nil
}

// Convert_autoscaling_MetricStatus_To_v2beta2_MetricStatus is an autogenerated conversion function.
func Convert_autoscaling_MetricStatus_To_v2beta2_MetricStatus(in *autoscaling.MetricStatus, out *autoscalingv2beta2.MetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricStatus_To_v2beta2_MetricStatus(in, out, s)
}

func autoConvert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(in *autoscalingv2beta2.MetricTarget, out *autoscaling.MetricTarget, s conversion.Scope) error {
        out.Type = autoscaling.MetricTargetType(in.Type)
        out.Value = (*resource.Quantity)(unsafe.Pointer(in.Value))
        out.AverageValue = (*resource.Quantity)(unsafe.Pointer(in.AverageValue))
        out.AverageUtilization = (*int32)(unsafe.Pointer(in.AverageUtilization))
        return nil
}

// Convert_v2beta2_MetricTarget_To_autoscaling_MetricTarget is an autogenerated conversion function.
func Convert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(in *autoscalingv2beta2.MetricTarget, out *autoscaling.MetricTarget, s conversion.Scope) error {
        return autoConvert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(in, out, s)
}

func autoConvert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(in *autoscaling.MetricTarget, out *autoscalingv2beta2.MetricTarget, s conversion.Scope) error {
        out.Type = autoscalingv2beta2.MetricTargetType(in.Type)
        out.Value = (*resource.Quantity)(unsafe.Pointer(in.Value))
        out.AverageValue = (*resource.Quantity)(unsafe.Pointer(in.AverageValue))
        out.AverageUtilization = (*int32)(unsafe.Pointer(in.AverageUtilization))
        return nil
}

// Convert_autoscaling_MetricTarget_To_v2beta2_MetricTarget is an autogenerated conversion function.
func Convert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(in *autoscaling.MetricTarget, out *autoscalingv2beta2.MetricTarget, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(in, out, s)
}

func autoConvert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(in *autoscalingv2beta2.MetricValueStatus, out *autoscaling.MetricValueStatus, s conversion.Scope) error {
        out.Value = (*resource.Quantity)(unsafe.Pointer(in.Value))
        out.AverageValue = (*resource.Quantity)(unsafe.Pointer(in.AverageValue))
        out.AverageUtilization = (*int32)(unsafe.Pointer(in.AverageUtilization))
        return nil
}

// Convert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus is an autogenerated conversion function.
func Convert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(in *autoscalingv2beta2.MetricValueStatus, out *autoscaling.MetricValueStatus, s conversion.Scope) error {
        return autoConvert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(in, out, s)
}

func autoConvert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(in *autoscaling.MetricValueStatus, out *autoscalingv2beta2.MetricValueStatus, s conversion.Scope) error {
        out.Value = (*resource.Quantity)(unsafe.Pointer(in.Value))
        out.AverageValue = (*resource.Quantity)(unsafe.Pointer(in.AverageValue))
        out.AverageUtilization = (*int32)(unsafe.Pointer(in.AverageUtilization))
        return nil
}

// Convert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus is an autogenerated conversion function.
func Convert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(in *autoscaling.MetricValueStatus, out *autoscalingv2beta2.MetricValueStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(in, out, s)
}

func autoConvert_v2beta2_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in *autoscalingv2beta2.ObjectMetricSource, out *autoscaling.ObjectMetricSource, s conversion.Scope) error {
        if err := Convert_v2beta2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.DescribedObject, &out.DescribedObject, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2beta2_ObjectMetricSource_To_autoscaling_ObjectMetricSource is an autogenerated conversion function.
func Convert_v2beta2_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in *autoscalingv2beta2.ObjectMetricSource, out *autoscaling.ObjectMetricSource, s conversion.Scope) error {
        return autoConvert_v2beta2_ObjectMetricSource_To_autoscaling_ObjectMetricSource(in, out, s)
}

func autoConvert_autoscaling_ObjectMetricSource_To_v2beta2_ObjectMetricSource(in *autoscaling.ObjectMetricSource, out *autoscalingv2beta2.ObjectMetricSource, s conversion.Scope) error {
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v2beta2_CrossVersionObjectReference(&in.DescribedObject, &out.DescribedObject, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ObjectMetricSource_To_v2beta2_ObjectMetricSource is an autogenerated conversion function.
func Convert_autoscaling_ObjectMetricSource_To_v2beta2_ObjectMetricSource(in *autoscaling.ObjectMetricSource, out *autoscalingv2beta2.ObjectMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_ObjectMetricSource_To_v2beta2_ObjectMetricSource(in, out, s)
}

func autoConvert_v2beta2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in *autoscalingv2beta2.ObjectMetricStatus, out *autoscaling.ObjectMetricStatus, s conversion.Scope) error {
        if err := Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_CrossVersionObjectReference_To_autoscaling_CrossVersionObjectReference(&in.DescribedObject, &out.DescribedObject, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2beta2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus is an autogenerated conversion function.
func Convert_v2beta2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in *autoscalingv2beta2.ObjectMetricStatus, out *autoscaling.ObjectMetricStatus, s conversion.Scope) error {
        return autoConvert_v2beta2_ObjectMetricStatus_To_autoscaling_ObjectMetricStatus(in, out, s)
}

func autoConvert_autoscaling_ObjectMetricStatus_To_v2beta2_ObjectMetricStatus(in *autoscaling.ObjectMetricStatus, out *autoscalingv2beta2.ObjectMetricStatus, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_CrossVersionObjectReference_To_v2beta2_CrossVersionObjectReference(&in.DescribedObject, &out.DescribedObject, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ObjectMetricStatus_To_v2beta2_ObjectMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_ObjectMetricStatus_To_v2beta2_ObjectMetricStatus(in *autoscaling.ObjectMetricStatus, out *autoscalingv2beta2.ObjectMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ObjectMetricStatus_To_v2beta2_ObjectMetricStatus(in, out, s)
}

func autoConvert_v2beta2_PodsMetricSource_To_autoscaling_PodsMetricSource(in *autoscalingv2beta2.PodsMetricSource, out *autoscaling.PodsMetricSource, s conversion.Scope) error {
        if err := Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2beta2_PodsMetricSource_To_autoscaling_PodsMetricSource is an autogenerated conversion function.
func Convert_v2beta2_PodsMetricSource_To_autoscaling_PodsMetricSource(in *autoscalingv2beta2.PodsMetricSource, out *autoscaling.PodsMetricSource, s conversion.Scope) error {
        return autoConvert_v2beta2_PodsMetricSource_To_autoscaling_PodsMetricSource(in, out, s)
}

func autoConvert_autoscaling_PodsMetricSource_To_v2beta2_PodsMetricSource(in *autoscaling.PodsMetricSource, out *autoscalingv2beta2.PodsMetricSource, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_PodsMetricSource_To_v2beta2_PodsMetricSource is an autogenerated conversion function.
func Convert_autoscaling_PodsMetricSource_To_v2beta2_PodsMetricSource(in *autoscaling.PodsMetricSource, out *autoscalingv2beta2.PodsMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_PodsMetricSource_To_v2beta2_PodsMetricSource(in, out, s)
}

func autoConvert_v2beta2_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in *autoscalingv2beta2.PodsMetricStatus, out *autoscaling.PodsMetricStatus, s conversion.Scope) error {
        if err := Convert_v2beta2_MetricIdentifier_To_autoscaling_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2beta2_PodsMetricStatus_To_autoscaling_PodsMetricStatus is an autogenerated conversion function.
func Convert_v2beta2_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in *autoscalingv2beta2.PodsMetricStatus, out *autoscaling.PodsMetricStatus, s conversion.Scope) error {
        return autoConvert_v2beta2_PodsMetricStatus_To_autoscaling_PodsMetricStatus(in, out, s)
}

func autoConvert_autoscaling_PodsMetricStatus_To_v2beta2_PodsMetricStatus(in *autoscaling.PodsMetricStatus, out *autoscalingv2beta2.PodsMetricStatus, s conversion.Scope) error {
        if err := Convert_autoscaling_MetricIdentifier_To_v2beta2_MetricIdentifier(&in.Metric, &out.Metric, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_PodsMetricStatus_To_v2beta2_PodsMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_PodsMetricStatus_To_v2beta2_PodsMetricStatus(in *autoscaling.PodsMetricStatus, out *autoscalingv2beta2.PodsMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_PodsMetricStatus_To_v2beta2_PodsMetricStatus(in, out, s)
}

func autoConvert_v2beta2_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in *autoscalingv2beta2.ResourceMetricSource, out *autoscaling.ResourceMetricSource, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        if err := Convert_v2beta2_MetricTarget_To_autoscaling_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2beta2_ResourceMetricSource_To_autoscaling_ResourceMetricSource is an autogenerated conversion function.
func Convert_v2beta2_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in *autoscalingv2beta2.ResourceMetricSource, out *autoscaling.ResourceMetricSource, s conversion.Scope) error {
        return autoConvert_v2beta2_ResourceMetricSource_To_autoscaling_ResourceMetricSource(in, out, s)
}

func autoConvert_autoscaling_ResourceMetricSource_To_v2beta2_ResourceMetricSource(in *autoscaling.ResourceMetricSource, out *autoscalingv2beta2.ResourceMetricSource, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        if err := Convert_autoscaling_MetricTarget_To_v2beta2_MetricTarget(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ResourceMetricSource_To_v2beta2_ResourceMetricSource is an autogenerated conversion function.
func Convert_autoscaling_ResourceMetricSource_To_v2beta2_ResourceMetricSource(in *autoscaling.ResourceMetricSource, out *autoscalingv2beta2.ResourceMetricSource, s conversion.Scope) error {
        return autoConvert_autoscaling_ResourceMetricSource_To_v2beta2_ResourceMetricSource(in, out, s)
}

func autoConvert_v2beta2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in *autoscalingv2beta2.ResourceMetricStatus, out *autoscaling.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        if err := Convert_v2beta2_MetricValueStatus_To_autoscaling_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_v2beta2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus is an autogenerated conversion function.
func Convert_v2beta2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in *autoscalingv2beta2.ResourceMetricStatus, out *autoscaling.ResourceMetricStatus, s conversion.Scope) error {
        return autoConvert_v2beta2_ResourceMetricStatus_To_autoscaling_ResourceMetricStatus(in, out, s)
}

func autoConvert_autoscaling_ResourceMetricStatus_To_v2beta2_ResourceMetricStatus(in *autoscaling.ResourceMetricStatus, out *autoscalingv2beta2.ResourceMetricStatus, s conversion.Scope) error {
        out.Name = v1.ResourceName(in.Name)
        if err := Convert_autoscaling_MetricValueStatus_To_v2beta2_MetricValueStatus(&in.Current, &out.Current, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_ResourceMetricStatus_To_v2beta2_ResourceMetricStatus is an autogenerated conversion function.
func Convert_autoscaling_ResourceMetricStatus_To_v2beta2_ResourceMetricStatus(in *autoscaling.ResourceMetricStatus, out *autoscalingv2beta2.ResourceMetricStatus, s conversion.Scope) error {
        return autoConvert_autoscaling_ResourceMetricStatus_To_v2beta2_ResourceMetricStatus(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v2beta2

import (
        autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&autoscalingv2beta2.HorizontalPodAutoscaler{}, func(obj interface{}) {
                SetObjectDefaults_HorizontalPodAutoscaler(obj.(*autoscalingv2beta2.HorizontalPodAutoscaler))
        })
        scheme.AddTypeDefaultingFunc(&autoscalingv2beta2.HorizontalPodAutoscalerList{}, func(obj interface{}) {
                SetObjectDefaults_HorizontalPodAutoscalerList(obj.(*autoscalingv2beta2.HorizontalPodAutoscalerList))
        })
        return nil
}

func SetObjectDefaults_HorizontalPodAutoscaler(in *autoscalingv2beta2.HorizontalPodAutoscaler) {
        SetDefaults_HorizontalPodAutoscaler(in)
}

func SetObjectDefaults_HorizontalPodAutoscalerList(in *autoscalingv2beta2.HorizontalPodAutoscalerList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_HorizontalPodAutoscaler(a)
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package validation

import (
        "fmt"

        apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
        pathvalidation "k8s.io/apimachinery/pkg/api/validation/path"
        "k8s.io/apimachinery/pkg/runtime/schema"
        "k8s.io/apimachinery/pkg/util/sets"
        "k8s.io/apimachinery/pkg/util/validation/field"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        corevalidation "k8s.io/kubernetes/pkg/apis/core/v1/validation"
        apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
)

const (
        // MaxPeriodSeconds is the largest allowed scaling policy period (in seconds)
        MaxPeriodSeconds int32 = 1800
        // MaxStabilizationWindowSeconds is the largest allowed stabilization window (in seconds)
        MaxStabilizationWindowSeconds int32 = 3600
)

// ValidateScale validates a Scale and returns an ErrorList with any errors.
func ValidateScale(scale *autoscaling.Scale) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, apivalidation.ValidateObjectMeta(&scale.ObjectMeta, true, apimachineryvalidation.NameIsDNSSubdomain, field.NewPath("metadata"))...)

        if scale.Spec.Replicas < 0 {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(scale.Spec.Replicas), field.NewPath("spec", "replicas")).MarkCoveredByDeclarative()...)
        }

        return allErrs
}

// ValidateHorizontalPodAutoscalerName can be used to check whether the given autoscaler name is valid.
// Prefix indicates this name will be used as part of generation, in which case trailing dashes are allowed.
var ValidateHorizontalPodAutoscalerName = apivalidation.ValidateReplicationControllerName

func validateHorizontalPodAutoscalerSpec(autoscaler autoscaling.HorizontalPodAutoscalerSpec, fldPath *field.Path, opts HorizontalPodAutoscalerSpecValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if autoscaler.MinReplicas != nil && *autoscaler.MinReplicas < opts.MinReplicasLowerBound {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("minReplicas"), *autoscaler.MinReplicas,
                        fmt.Sprintf("must be greater than or equal to %d", opts.MinReplicasLowerBound)))
        }
        if autoscaler.MaxReplicas < 1 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("maxReplicas"), autoscaler.MaxReplicas, "must be greater than 0"))
        }
        if autoscaler.MinReplicas != nil && autoscaler.MaxReplicas < *autoscaler.MinReplicas {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("maxReplicas"), autoscaler.MaxReplicas, "must be greater than or equal to `minReplicas`"))
        }
        if refErrs := ValidateCrossVersionObjectReference(autoscaler.ScaleTargetRef, fldPath.Child("scaleTargetRef"), opts.ScaleTargetRefValidationOptions); len(refErrs) > 0 {
                allErrs = append(allErrs, refErrs...)
        }
        if refErrs := validateMetrics(autoscaler.Metrics, fldPath.Child("metrics"), autoscaler.MinReplicas, opts.ObjectMetricsValidationOptions); len(refErrs) > 0 {
                allErrs = append(allErrs, refErrs...)
        }
        if refErrs := validateBehavior(autoscaler.Behavior, fldPath.Child("behavior"), opts); len(refErrs) > 0 {
                allErrs = append(allErrs, refErrs...)
        }
        return allErrs
}

// ValidateCrossVersionObjectReference validates a CrossVersionObjectReference and returns an
// ErrorList with any errors.
func ValidateCrossVersionObjectReference(ref autoscaling.CrossVersionObjectReference, fldPath *field.Path, opts CrossVersionObjectReferenceValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(ref.Kind) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("kind"), ""))
        } else {
                for _, msg := range pathvalidation.IsValidPathSegmentName(ref.Kind) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("kind"), ref.Kind, msg))
                }
        }

        if len(ref.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        } else {
                for _, msg := range pathvalidation.IsValidPathSegmentName(ref.Name) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), ref.Name, msg))
                }
        }
        if err := ValidateAPIVersion(ref, opts); err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("apiVersion"), ref.APIVersion, err.Error()))
        }
        return allErrs
}

func ValidateAPIVersion(ref autoscaling.CrossVersionObjectReference, opts CrossVersionObjectReferenceValidationOptions) error {
        if opts.AllowInvalidAPIVersion {
                return nil
        }
        gv, err := schema.ParseGroupVersion(ref.APIVersion)
        if err != nil {
                return err
        } else if !opts.AllowEmptyAPIGroup && gv.Group == "" {
                return fmt.Errorf("apiVersion must specify API group")
        }
        return nil
}

// ValidateHorizontalPodAutoscaler validates a HorizontalPodAutoscaler and returns an
// ErrorList with any errors.
func ValidateHorizontalPodAutoscaler(autoscaler *autoscaling.HorizontalPodAutoscaler, opts HorizontalPodAutoscalerSpecValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMeta(&autoscaler.ObjectMeta, true, ValidateHorizontalPodAutoscalerName, field.NewPath("metadata"))
        allErrs = append(allErrs, validateHorizontalPodAutoscalerSpec(autoscaler.Spec, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateHorizontalPodAutoscalerUpdate validates an update to a HorizontalPodAutoscaler and returns an
// ErrorList with any errors.
func ValidateHorizontalPodAutoscalerUpdate(newAutoscaler, oldAutoscaler *autoscaling.HorizontalPodAutoscaler, opts HorizontalPodAutoscalerSpecValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&newAutoscaler.ObjectMeta, &oldAutoscaler.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, validateHorizontalPodAutoscalerSpec(newAutoscaler.Spec, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateHorizontalPodAutoscalerStatusUpdate validates an update to status on a HorizontalPodAutoscaler and
// returns an ErrorList with any errors.
func ValidateHorizontalPodAutoscalerStatusUpdate(newAutoscaler, oldAutoscaler *autoscaling.HorizontalPodAutoscaler) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&newAutoscaler.ObjectMeta, &oldAutoscaler.ObjectMeta, field.NewPath("metadata"))
        status := newAutoscaler.Status
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.CurrentReplicas), field.NewPath("status", "currentReplicas"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.DesiredReplicas), field.NewPath("status", "desiredReplicas"))...)
        return allErrs
}

// CrossVersionObjectReferenceValidationOptions contains the different setting
// to validate CrossVersionObjectReference.
type CrossVersionObjectReferenceValidationOptions struct {
        // Whether to allow API Version empty
        AllowEmptyAPIGroup bool
        // AllowInvalidAPIVersion skips APIVersion validation when true.
        AllowInvalidAPIVersion bool
}

// HorizontalPodAutoscalerSpecValidationOptions contains the different settings for
// HorizontalPodAutoscaler spec validation.
type HorizontalPodAutoscalerSpecValidationOptions struct {
        // The minimum value for minReplicas.
        MinReplicasLowerBound           int32
        ScaleTargetRefValidationOptions CrossVersionObjectReferenceValidationOptions
        ObjectMetricsValidationOptions  CrossVersionObjectReferenceValidationOptions
}

func validateMetrics(newMetrics []autoscaling.MetricSpec, fldPath *field.Path, minReplicas *int32, opts CrossVersionObjectReferenceValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        hasObjectMetrics := false
        hasExternalMetrics := false
        for i, metricSpec := range newMetrics {
                idxPath := fldPath.Index(i)
                if targetErrs := validateMetricSpec(metricSpec, idxPath, opts); len(targetErrs) > 0 {
                        allErrs = append(allErrs, targetErrs...)
                }
                if metricSpec.Type == autoscaling.ObjectMetricSourceType {
                        hasObjectMetrics = true
                }
                if metricSpec.Type == autoscaling.ExternalMetricSourceType {
                        hasExternalMetrics = true
                }
        }

        if minReplicas != nil && *minReplicas == 0 {
                if !hasObjectMetrics && !hasExternalMetrics {
                        allErrs = append(allErrs, field.Forbidden(fldPath, "must specify at least one Object or External metric to support scaling to zero replicas"))
                }
        }

        return allErrs
}

func validateBehavior(behavior *autoscaling.HorizontalPodAutoscalerBehavior, fldPath *field.Path, opts HorizontalPodAutoscalerSpecValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if behavior != nil {
                if scaleUpErrs := validateScalingRules(behavior.ScaleUp, fldPath.Child("scaleUp"), opts); len(scaleUpErrs) > 0 {
                        allErrs = append(allErrs, scaleUpErrs...)
                }
                if scaleDownErrs := validateScalingRules(behavior.ScaleDown, fldPath.Child("scaleDown"), opts); len(scaleDownErrs) > 0 {
                        allErrs = append(allErrs, scaleDownErrs...)
                }
        }
        return allErrs
}

var validSelectPolicyTypes = sets.NewString(string(autoscaling.MaxPolicySelect), string(autoscaling.MinPolicySelect), string(autoscaling.DisabledPolicySelect))
var validSelectPolicyTypesList = validSelectPolicyTypes.List()

func validateScalingRules(rules *autoscaling.HPAScalingRules, fldPath *field.Path, opts HorizontalPodAutoscalerSpecValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if rules != nil {
                if rules.StabilizationWindowSeconds != nil && *rules.StabilizationWindowSeconds < 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("stabilizationWindowSeconds"), rules.StabilizationWindowSeconds, "must be greater than or equal to zero"))
                }
                if rules.StabilizationWindowSeconds != nil && *rules.StabilizationWindowSeconds > MaxStabilizationWindowSeconds {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("stabilizationWindowSeconds"), rules.StabilizationWindowSeconds,
                                fmt.Sprintf("must be less than or equal to %v", MaxStabilizationWindowSeconds)))
                }
                if rules.SelectPolicy != nil && !validSelectPolicyTypes.Has(string(*rules.SelectPolicy)) {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("selectPolicy"), rules.SelectPolicy, validSelectPolicyTypesList))
                }
                policiesPath := fldPath.Child("policies")
                if len(rules.Policies) == 0 {
                        allErrs = append(allErrs, field.Required(policiesPath, "must specify at least one Policy"))
                }
                for i, policy := range rules.Policies {
                        idxPath := policiesPath.Index(i)
                        if policyErrs := validateScalingPolicy(policy, idxPath); len(policyErrs) > 0 {
                                allErrs = append(allErrs, policyErrs...)
                        }
                }
                if rules.Tolerance != nil {
                        allErrs = append(allErrs, apivalidation.ValidateNonnegativeQuantity(*rules.Tolerance, fldPath.Child("tolerance"))...)
                }
        }
        return allErrs
}

var validPolicyTypes = sets.NewString(string(autoscaling.PodsScalingPolicy), string(autoscaling.PercentScalingPolicy))
var validPolicyTypesList = validPolicyTypes.List()

func validateScalingPolicy(policy autoscaling.HPAScalingPolicy, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if policy.Type != autoscaling.PodsScalingPolicy && policy.Type != autoscaling.PercentScalingPolicy {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("type"), policy.Type, validPolicyTypesList))
        }
        if policy.Value <= 0 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("value"), policy.Value, "must be greater than zero"))
        }
        if policy.PeriodSeconds <= 0 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("periodSeconds"), policy.PeriodSeconds, "must be greater than zero"))
        }
        if policy.PeriodSeconds > MaxPeriodSeconds {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("periodSeconds"), policy.PeriodSeconds,
                        fmt.Sprintf("must be less than or equal to %v", MaxPeriodSeconds)))
        }
        return allErrs
}

var validMetricSourceTypes = sets.NewString(
        string(autoscaling.ObjectMetricSourceType), string(autoscaling.PodsMetricSourceType),
        string(autoscaling.ResourceMetricSourceType), string(autoscaling.ExternalMetricSourceType),
        string(autoscaling.ContainerResourceMetricSourceType))
var validMetricSourceTypesList = validMetricSourceTypes.List()

func validateMetricSpec(spec autoscaling.MetricSpec, fldPath *field.Path, opts CrossVersionObjectReferenceValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(string(spec.Type)) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("type"), "must specify a metric source type"))
        }

        if !validMetricSourceTypes.Has(string(spec.Type)) {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("type"), spec.Type, validMetricSourceTypesList))
        }

        typesPresent := sets.NewString()
        if spec.Object != nil {
                typesPresent.Insert("object")
                if typesPresent.Len() == 1 {
                        allErrs = append(allErrs, validateObjectSource(spec.Object, fldPath.Child("object"), opts)...)
                }
        }

        if spec.External != nil {
                typesPresent.Insert("external")
                if typesPresent.Len() == 1 {
                        allErrs = append(allErrs, validateExternalSource(spec.External, fldPath.Child("external"))...)
                }
        }

        if spec.Pods != nil {
                typesPresent.Insert("pods")
                if typesPresent.Len() == 1 {
                        allErrs = append(allErrs, validatePodsSource(spec.Pods, fldPath.Child("pods"))...)
                }
        }

        if spec.Resource != nil {
                typesPresent.Insert("resource")
                if typesPresent.Len() == 1 {
                        allErrs = append(allErrs, validateResourceSource(spec.Resource, fldPath.Child("resource"))...)
                }
        }

        if spec.ContainerResource != nil {
                typesPresent.Insert("containerResource")
                if typesPresent.Len() == 1 {
                        allErrs = append(allErrs, validateContainerResourceSource(spec.ContainerResource, fldPath.Child("containerResource"))...)
                }
        }

        var expectedField string
        switch spec.Type {

        case autoscaling.ObjectMetricSourceType:
                if spec.Object == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("object"), "must populate information for the given metric source"))
                }
                expectedField = "object"
        case autoscaling.PodsMetricSourceType:
                if spec.Pods == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("pods"), "must populate information for the given metric source"))
                }
                expectedField = "pods"
        case autoscaling.ResourceMetricSourceType:
                if spec.Resource == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("resource"), "must populate information for the given metric source"))
                }
                expectedField = "resource"
        case autoscaling.ExternalMetricSourceType:
                if spec.External == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("external"), "must populate information for the given metric source"))
                }
                expectedField = "external"
        case autoscaling.ContainerResourceMetricSourceType:
                if spec.ContainerResource == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("containerResource"), "must populate information for the given metric source"))
                }
                expectedField = "containerResource"
        default:
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("type"), spec.Type, validMetricSourceTypesList))
        }

        if typesPresent.Len() != 1 {
                typesPresent.Delete(expectedField)
                for typ := range typesPresent {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child(typ), "must populate the given metric source only"))
                }
        }

        return allErrs
}

func validateObjectSource(src *autoscaling.ObjectMetricSource, fldPath *field.Path, opts CrossVersionObjectReferenceValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateCrossVersionObjectReference(src.DescribedObject, fldPath.Child("describedObject"), opts)...)
        allErrs = append(allErrs, validateMetricIdentifier(src.Metric, fldPath.Child("metric"))...)
        allErrs = append(allErrs, validateMetricTarget(src.Target, fldPath.Child("target"))...)

        if src.Target.Value == nil && src.Target.AverageValue == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("target").Child("averageValue"), "must set either a target value or averageValue"))
        }

        return allErrs
}

func validateExternalSource(src *autoscaling.ExternalMetricSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        allErrs = append(allErrs, validateMetricIdentifier(src.Metric, fldPath.Child("metric"))...)
        allErrs = append(allErrs, validateMetricTarget(src.Target, fldPath.Child("target"))...)

        if src.Target.Value == nil && src.Target.AverageValue == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("target").Child("averageValue"), "must set either a target value for metric or a per-pod target"))
        }

        if src.Target.Value != nil && src.Target.AverageValue != nil {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("target").Child("value"), "may not set both a target value for metric and a per-pod target"))
        }

        return allErrs
}

func validatePodsSource(src *autoscaling.PodsMetricSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        allErrs = append(allErrs, validateMetricIdentifier(src.Metric, fldPath.Child("metric"))...)
        allErrs = append(allErrs, validateMetricTarget(src.Target, fldPath.Child("target"))...)

        if src.Target.AverageValue == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("target").Child("averageValue"), "must specify a positive target averageValue"))
        }

        return allErrs
}

func validateContainerResourceSource(src *autoscaling.ContainerResourceMetricSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(src.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), "must specify a resource name"))
        } else {
                allErrs = append(allErrs, corevalidation.ValidateContainerResourceName(src.Name, fldPath.Child("name"))...)
        }

        if len(src.Container) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("container"), "must specify a container"))
        } else {
                allErrs = append(allErrs, apivalidation.ValidateDNS1123Label(src.Container, fldPath.Child("container"))...)
        }

        allErrs = append(allErrs, validateMetricTarget(src.Target, fldPath.Child("target"))...)

        if src.Target.AverageUtilization == nil && src.Target.AverageValue == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("target").Child("averageUtilization"), "must set either a target raw value or a target utilization"))
        }

        if src.Target.AverageUtilization != nil && src.Target.AverageValue != nil {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("target").Child("averageValue"), "may not set both a target raw value and a target utilization"))
        }

        return allErrs
}

func validateResourceSource(src *autoscaling.ResourceMetricSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(src.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), "must specify a resource name"))
        }

        allErrs = append(allErrs, validateMetricTarget(src.Target, fldPath.Child("target"))...)

        if src.Target.AverageUtilization == nil && src.Target.AverageValue == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("target").Child("averageUtilization"), "must set either a target raw value or a target utilization"))
        }

        if src.Target.AverageUtilization != nil && src.Target.AverageValue != nil {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("target").Child("averageValue"), "may not set both a target raw value and a target utilization"))
        }

        return allErrs
}

func validateMetricTarget(mt autoscaling.MetricTarget, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(mt.Type) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("type"), "must specify a metric target type"))
        }

        if mt.Type != autoscaling.UtilizationMetricType &&
                mt.Type != autoscaling.ValueMetricType &&
                mt.Type != autoscaling.AverageValueMetricType {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("type"), mt.Type, "must be either Utilization, Value, or AverageValue"))
        }

        if mt.Value != nil && mt.Value.Sign() != 1 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("value"), mt.Value, "must be positive"))
        }

        if mt.AverageValue != nil && mt.AverageValue.Sign() != 1 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("averageValue"), mt.AverageValue, "must be positive"))
        }

        if mt.AverageUtilization != nil && *mt.AverageUtilization < 1 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("averageUtilization"), mt.AverageUtilization, "must be greater than 0"))
        }

        return allErrs
}

func validateMetricIdentifier(id autoscaling.MetricIdentifier, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(id.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), "must specify a metric name"))
        } else {
                for _, msg := range pathvalidation.IsValidPathSegmentName(id.Name) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), id.Name, msg))
                }
        }
        return allErrs
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package autoscaling

import (
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerResourceMetricSource) DeepCopyInto(out *ContainerResourceMetricSource) {
        *out = *in
        in.Target.DeepCopyInto(&out.Target)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerResourceMetricSource.
func (in *ContainerResourceMetricSource) DeepCopy() *ContainerResourceMetricSource {
        if in == nil {
                return nil
        }
        out := new(ContainerResourceMetricSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerResourceMetricStatus) DeepCopyInto(out *ContainerResourceMetricStatus) {
        *out = *in
        in.Current.DeepCopyInto(&out.Current)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerResourceMetricStatus.
func (in *ContainerResourceMetricStatus) DeepCopy() *ContainerResourceMetricStatus {
        if in == nil {
                return nil
        }
        out := new(ContainerResourceMetricStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CrossVersionObjectReference) DeepCopyInto(out *CrossVersionObjectReference) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CrossVersionObjectReference.
func (in *CrossVersionObjectReference) DeepCopy() *CrossVersionObjectReference {
        if in == nil {
                return nil
        }
        out := new(CrossVersionObjectReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ExternalMetricSource) DeepCopyInto(out *ExternalMetricSource) {
        *out = *in
        in.Metric.DeepCopyInto(&out.Metric)
        in.Target.DeepCopyInto(&out.Target)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalMetricSource.
func (in *ExternalMetricSource) DeepCopy() *ExternalMetricSource {
        if in == nil {
                return nil
        }
        out := new(ExternalMetricSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ExternalMetricStatus) DeepCopyInto(out *ExternalMetricStatus) {
        *out = *in
        in.Metric.DeepCopyInto(&out.Metric)
        in.Current.DeepCopyInto(&out.Current)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalMetricStatus.
func (in *ExternalMetricStatus) DeepCopy() *ExternalMetricStatus {
        if in == nil {
                return nil
        }
        out := new(ExternalMetricStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HPAScalingPolicy) DeepCopyInto(out *HPAScalingPolicy) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HPAScalingPolicy.
func (in *HPAScalingPolicy) DeepCopy() *HPAScalingPolicy {
        if in == nil {
                return nil
        }
        out := new(HPAScalingPolicy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HPAScalingRules) DeepCopyInto(out *HPAScalingRules) {
        *out = *in
        if in.StabilizationWindowSeconds != nil {
                in, out := &in.StabilizationWindowSeconds, &out.StabilizationWindowSeconds
                *out = new(int32)
                **out = **in
        }
        if in.SelectPolicy != nil {
                in, out := &in.SelectPolicy, &out.SelectPolicy
                *out = new(ScalingPolicySelect)
                **out = **in
        }
        if in.Policies != nil {
                in, out := &in.Policies, &out.Policies
                *out = make([]HPAScalingPolicy, len(*in))
                copy(*out, *in)
        }
        if in.Tolerance != nil {
                in, out := &in.Tolerance, &out.Tolerance
                x := (*in).DeepCopy()
                *out = &x
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HPAScalingRules.
func (in *HPAScalingRules) DeepCopy() *HPAScalingRules {
        if in == nil {
                return nil
        }
        out := new(HPAScalingRules)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HorizontalPodAutoscaler) DeepCopyInto(out *HorizontalPodAutoscaler) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscaler.
func (in *HorizontalPodAutoscaler) DeepCopy() *HorizontalPodAutoscaler {
        if in == nil {
                return nil
        }
        out := new(HorizontalPodAutoscaler)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *HorizontalPodAutoscaler) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HorizontalPodAutoscalerBehavior) DeepCopyInto(out *HorizontalPodAutoscalerBehavior) {
        *out = *in
        if in.ScaleUp != nil {
                in, out := &in.ScaleUp, &out.ScaleUp
                *out = new(HPAScalingRules)
                (*in).DeepCopyInto(*out)
        }
        if in.ScaleDown != nil {
                in, out := &in.ScaleDown, &out.ScaleDown
                *out = new(HPAScalingRules)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerBehavior.
func (in *HorizontalPodAutoscalerBehavior) DeepCopy() *HorizontalPodAutoscalerBehavior {
        if in == nil {
                return nil
        }
        out := new(HorizontalPodAutoscalerBehavior)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HorizontalPodAutoscalerCondition) DeepCopyInto(out *HorizontalPodAutoscalerCondition) {
        *out = *in
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerCondition.
func (in *HorizontalPodAutoscalerCondition) DeepCopy() *HorizontalPodAutoscalerCondition {
        if in == nil {
                return nil
        }
        out := new(HorizontalPodAutoscalerCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HorizontalPodAutoscalerList) DeepCopyInto(out *HorizontalPodAutoscalerList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]HorizontalPodAutoscaler, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerList.
func (in *HorizontalPodAutoscalerList) DeepCopy() *HorizontalPodAutoscalerList {
        if in == nil {
                return nil
        }
        out := new(HorizontalPodAutoscalerList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *HorizontalPodAutoscalerList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HorizontalPodAutoscalerSpec) DeepCopyInto(out *HorizontalPodAutoscalerSpec) {
        *out = *in
        out.ScaleTargetRef = in.ScaleTargetRef
        if in.MinReplicas != nil {
                in, out := &in.MinReplicas, &out.MinReplicas
                *out = new(int32)
                **out = **in
        }
        if in.Metrics != nil {
                in, out := &in.Metrics, &out.Metrics
                *out = make([]MetricSpec, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Behavior != nil {
                in, out := &in.Behavior, &out.Behavior
                *out = new(HorizontalPodAutoscalerBehavior)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerSpec.
func (in *HorizontalPodAutoscalerSpec) DeepCopy() *HorizontalPodAutoscalerSpec {
        if in == nil {
                return nil
        }
        out := new(HorizontalPodAutoscalerSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HorizontalPodAutoscalerStatus) DeepCopyInto(out *HorizontalPodAutoscalerStatus) {
        *out = *in
        if in.ObservedGeneration != nil {
                in, out := &in.ObservedGeneration, &out.ObservedGeneration
                *out = new(int64)
                **out = **in
        }
        if in.LastScaleTime != nil {
                in, out := &in.LastScaleTime, &out.LastScaleTime
                *out = (*in).DeepCopy()
        }
        if in.CurrentMetrics != nil {
                in, out := &in.CurrentMetrics, &out.CurrentMetrics
                *out = make([]MetricStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]HorizontalPodAutoscalerCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HorizontalPodAutoscalerStatus.
func (in *HorizontalPodAutoscalerStatus) DeepCopy() *HorizontalPodAutoscalerStatus {
        if in == nil {
                return nil
        }
        out := new(HorizontalPodAutoscalerStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MetricIdentifier) DeepCopyInto(out *MetricIdentifier) {
        *out = *in
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricIdentifier.
func (in *MetricIdentifier) DeepCopy() *MetricIdentifier {
        if in == nil {
                return nil
        }
        out := new(MetricIdentifier)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MetricSpec) DeepCopyInto(out *MetricSpec) {
        *out = *in
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(ObjectMetricSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(PodsMetricSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(ResourceMetricSource)
                (*in).DeepCopyInto(*out)
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(ContainerResourceMetricSource)
                (*in).DeepCopyInto(*out)
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(ExternalMetricSource)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricSpec.
func (in *MetricSpec) DeepCopy() *MetricSpec {
        if in == nil {
                return nil
        }
        out := new(MetricSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MetricStatus) DeepCopyInto(out *MetricStatus) {
        *out = *in
        if in.Object != nil {
                in, out := &in.Object, &out.Object
                *out = new(ObjectMetricStatus)
                (*in).DeepCopyInto(*out)
        }
        if in.Pods != nil {
                in, out := &in.Pods, &out.Pods
                *out = new(PodsMetricStatus)
                (*in).DeepCopyInto(*out)
        }
        if in.Resource != nil {
                in, out := &in.Resource, &out.Resource
                *out = new(ResourceMetricStatus)
                (*in).DeepCopyInto(*out)
        }
        if in.ContainerResource != nil {
                in, out := &in.ContainerResource, &out.ContainerResource
                *out = new(ContainerResourceMetricStatus)
                (*in).DeepCopyInto(*out)
        }
        if in.External != nil {
                in, out := &in.External, &out.External
                *out = new(ExternalMetricStatus)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricStatus.
func (in *MetricStatus) DeepCopy() *MetricStatus {
        if in == nil {
                return nil
        }
        out := new(MetricStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MetricTarget) DeepCopyInto(out *MetricTarget) {
        *out = *in
        if in.Value != nil {
                in, out := &in.Value, &out.Value
                x := (*in).DeepCopy()
                *out = &x
        }
        if in.AverageValue != nil {
                in, out := &in.AverageValue, &out.AverageValue
                x := (*in).DeepCopy()
                *out = &x
        }
        if in.AverageUtilization != nil {
                in, out := &in.AverageUtilization, &out.AverageUtilization
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricTarget.
func (in *MetricTarget) DeepCopy() *MetricTarget {
        if in == nil {
                return nil
        }
        out := new(MetricTarget)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *MetricValueStatus) DeepCopyInto(out *MetricValueStatus) {
        *out = *in
        if in.Value != nil {
                in, out := &in.Value, &out.Value
                x := (*in).DeepCopy()
                *out = &x
        }
        if in.AverageValue != nil {
                in, out := &in.AverageValue, &out.AverageValue
                x := (*in).DeepCopy()
                *out = &x
        }
        if in.AverageUtilization != nil {
                in, out := &in.AverageUtilization, &out.AverageUtilization
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricValueStatus.
func (in *MetricValueStatus) DeepCopy() *MetricValueStatus {
        if in == nil {
                return nil
        }
        out := new(MetricValueStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ObjectMetricSource) DeepCopyInto(out *ObjectMetricSource) {
        *out = *in
        out.DescribedObject = in.DescribedObject
        in.Target.DeepCopyInto(&out.Target)
        in.Metric.DeepCopyInto(&out.Metric)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectMetricSource.
func (in *ObjectMetricSource) DeepCopy() *ObjectMetricSource {
        if in == nil {
                return nil
        }
        out := new(ObjectMetricSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ObjectMetricStatus) DeepCopyInto(out *ObjectMetricStatus) {
        *out = *in
        in.Metric.DeepCopyInto(&out.Metric)
        in.Current.DeepCopyInto(&out.Current)
        out.DescribedObject = in.DescribedObject
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectMetricStatus.
func (in *ObjectMetricStatus) DeepCopy() *ObjectMetricStatus {
        if in == nil {
                return nil
        }
        out := new(ObjectMetricStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodsMetricSource) DeepCopyInto(out *PodsMetricSource) {
        *out = *in
        in.Metric.DeepCopyInto(&out.Metric)
        in.Target.DeepCopyInto(&out.Target)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodsMetricSource.
func (in *PodsMetricSource) DeepCopy() *PodsMetricSource {
        if in == nil {
                return nil
        }
        out := new(PodsMetricSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodsMetricStatus) DeepCopyInto(out *PodsMetricStatus) {
        *out = *in
        in.Metric.DeepCopyInto(&out.Metric)
        in.Current.DeepCopyInto(&out.Current)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodsMetricStatus.
func (in *PodsMetricStatus) DeepCopy() *PodsMetricStatus {
        if in == nil {
                return nil
        }
        out := new(PodsMetricStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceMetricSource) DeepCopyInto(out *ResourceMetricSource) {
        *out = *in
        in.Target.DeepCopyInto(&out.Target)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceMetricSource.
func (in *ResourceMetricSource) DeepCopy() *ResourceMetricSource {
        if in == nil {
                return nil
        }
        out := new(ResourceMetricSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceMetricStatus) DeepCopyInto(out *ResourceMetricStatus) {
        *out = *in
        in.Current.DeepCopyInto(&out.Current)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceMetricStatus.
func (in *ResourceMetricStatus) DeepCopy() *ResourceMetricStatus {
        if in == nil {
                return nil
        }
        out := new(ResourceMetricStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Scale) DeepCopyInto(out *Scale) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        out.Spec = in.Spec
        out.Status = in.Status
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Scale.
func (in *Scale) DeepCopy() *Scale {
        if in == nil {
                return nil
        }
        out := new(Scale)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Scale) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ScaleSpec) DeepCopyInto(out *ScaleSpec) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScaleSpec.
func (in *ScaleSpec) DeepCopy() *ScaleSpec {
        if in == nil {
                return nil
        }
        out := new(ScaleSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ScaleStatus) DeepCopyInto(out *ScaleStatus) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScaleStatus.
func (in *ScaleStatus) DeepCopy() *ScaleStatus {
        if in == nil {
                return nil
        }
        out := new(ScaleStatus)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        "math"

        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
        "k8s.io/kubernetes/pkg/apis/batch"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/utils/ptr"
        "sigs.k8s.io/randfill"
)

// Funcs returns the fuzzer functions for the batch api group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(j *batch.Job, c randfill.Continue) {
                        c.FillNoCustom(j) // fuzz self without calling this function again

                        // match defaulting
                        if len(j.Labels) == 0 {
                                j.Labels = j.Spec.Template.Labels
                        }
                },
                func(j *batch.JobSpec, c randfill.Continue) {
                        c.FillNoCustom(j) // fuzz self without calling this function again
                        completions := c.Int31()
                        parallelism := c.Int31()
                        backoffLimit := c.Int31()
                        j.Completions = &completions
                        j.Parallelism = &parallelism
                        j.BackoffLimit = &backoffLimit
                        j.ManualSelector = ptr.To(c.Bool())
                        mode := batch.NonIndexedCompletion
                        if c.Bool() {
                                mode = batch.IndexedCompletion
                                j.BackoffLimitPerIndex = ptr.To[int32](c.Int31())
                                j.MaxFailedIndexes = ptr.To[int32](c.Int31())
                        }
                        if c.Bool() {
                                j.BackoffLimit = ptr.To[int32](math.MaxInt32)
                        }
                        j.CompletionMode = &mode
                        // We're fuzzing the internal JobSpec type, not the v1 type, so we don't
                        // need to fuzz the nil value.
                        j.Suspend = ptr.To(c.Bool())
                        podReplacementPolicy := batch.TerminatingOrFailed
                        if c.Bool() {
                                podReplacementPolicy = batch.Failed
                        }
                        j.PodReplacementPolicy = &podReplacementPolicy
                        if c.Bool() {
                                c.Fill(j.ManagedBy)
                        }
                },
                func(sj *batch.CronJobSpec, c randfill.Continue) {
                        c.FillNoCustom(sj)
                        suspend := c.Bool()
                        sj.Suspend = &suspend
                        sds := int64(c.Uint64())
                        sj.StartingDeadlineSeconds = &sds
                        sj.Schedule = c.String(0)
                        successfulJobsHistoryLimit := c.Int31()
                        sj.SuccessfulJobsHistoryLimit = &successfulJobsHistoryLimit
                        failedJobsHistoryLimit := c.Int31()
                        sj.FailedJobsHistoryLimit = &failedJobsHistoryLimit
                },
                func(cp *batch.ConcurrencyPolicy, c randfill.Continue) {
                        policies := []batch.ConcurrencyPolicy{batch.AllowConcurrent, batch.ForbidConcurrent, batch.ReplaceConcurrent}
                        *cp = policies[c.Rand.Intn(len(policies))]
                },
                func(p *batch.PodFailurePolicyOnPodConditionsPattern, c randfill.Continue) {
                        c.FillNoCustom(p)
                        if p.Status == "" {
                                p.Status = api.ConditionTrue
                        }
                },
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

// Package install installs the batch API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/batch"
        "k8s.io/kubernetes/pkg/apis/batch/v1"
        "k8s.io/kubernetes/pkg/apis/batch/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(batch.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion))
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package batch

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "batch"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder points to a list of functions added to Scheme.
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme applies all the stored functions to the scheme.
        AddToScheme = SchemeBuilder.AddToScheme
)

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &Job{},
                &JobList{},
                &CronJob{},
                &CronJobList{},
        )
        return nil
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1

import (
        "fmt"

        v1 "k8s.io/api/batch/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/kubernetes/pkg/apis/batch"
)

func addConversionFuncs(scheme *runtime.Scheme) error {
        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Job"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name", "metadata.namespace", "status.successful":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label %q not supported for Job", label)
                        }
                })
}

// The following functions don't do anything special, but they need to be added
// here due to the dependency of v1beta1 on v1.

func Convert_batch_JobSpec_To_v1_JobSpec(in *batch.JobSpec, out *v1.JobSpec, s conversion.Scope) error {
        return autoConvert_batch_JobSpec_To_v1_JobSpec(in, out, s)
}

func Convert_v1_JobSpec_To_batch_JobSpec(in *v1.JobSpec, out *batch.JobSpec, s conversion.Scope) error {
        return autoConvert_v1_JobSpec_To_batch_JobSpec(in, out, s)
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1

import (
        "math"

        batchv1 "k8s.io/api/batch/v1"
        corev1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        "k8s.io/kubernetes/pkg/features"
        "k8s.io/utils/ptr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_Job(obj *batchv1.Job) {
        // For a non-parallel job, you can leave both `.spec.completions` and
        // `.spec.parallelism` unset.  When both are unset, both are defaulted to 1.
        if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
                obj.Spec.Completions = ptr.To[int32](1)
                obj.Spec.Parallelism = ptr.To[int32](1)
        }
        if obj.Spec.Parallelism == nil {
                obj.Spec.Parallelism = ptr.To[int32](1)
        }
        if obj.Spec.BackoffLimit == nil {
                if obj.Spec.BackoffLimitPerIndex != nil {
                        obj.Spec.BackoffLimit = ptr.To[int32](math.MaxInt32)
                } else {
                        obj.Spec.BackoffLimit = ptr.To[int32](6)
                }
        }
        labels := obj.Spec.Template.Labels
        if labels != nil && len(obj.Labels) == 0 {
                obj.Labels = labels
        }
        if obj.Spec.CompletionMode == nil {
                mode := batchv1.NonIndexedCompletion
                obj.Spec.CompletionMode = &mode
        }
        if obj.Spec.Suspend == nil {
                obj.Spec.Suspend = ptr.To(false)
        }
        if utilfeature.DefaultFeatureGate.Enabled(features.JobPodReplacementPolicy) {
                if obj.Spec.PodReplacementPolicy == nil {
                        if obj.Spec.PodFailurePolicy != nil {
                                obj.Spec.PodReplacementPolicy = ptr.To(batchv1.Failed)
                        } else {
                                obj.Spec.PodReplacementPolicy = ptr.To(batchv1.TerminatingOrFailed)
                        }
                }
        }
        if obj.Spec.ManualSelector == nil {
                obj.Spec.ManualSelector = ptr.To(false)
        }
}

func SetDefaults_CronJob(obj *batchv1.CronJob) {
        if obj.Spec.ConcurrencyPolicy == "" {
                obj.Spec.ConcurrencyPolicy = batchv1.AllowConcurrent
        }
        if obj.Spec.Suspend == nil {
                obj.Spec.Suspend = ptr.To(false)
        }
        if obj.Spec.SuccessfulJobsHistoryLimit == nil {
                obj.Spec.SuccessfulJobsHistoryLimit = ptr.To[int32](3)
        }
        if obj.Spec.FailedJobsHistoryLimit == nil {
                obj.Spec.FailedJobsHistoryLimit = ptr.To[int32](1)
        }
}

func SetDefaults_PodFailurePolicyOnPodConditionsPattern(obj *batchv1.PodFailurePolicyOnPodConditionsPattern) {
        if obj.Status == "" {
                obj.Status = corev1.ConditionTrue
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1

import (
        batchv1 "k8s.io/api/batch/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "batch"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &batchv1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        batchv1 "k8s.io/api/batch/v1"
        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        types "k8s.io/apimachinery/pkg/types"
        batch "k8s.io/kubernetes/pkg/apis/batch"
        core "k8s.io/kubernetes/pkg/apis/core"
        apiscorev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*batchv1.CronJob)(nil), (*batch.CronJob)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CronJob_To_batch_CronJob(a.(*batchv1.CronJob), b.(*batch.CronJob), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.CronJob)(nil), (*batchv1.CronJob)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_CronJob_To_v1_CronJob(a.(*batch.CronJob), b.(*batchv1.CronJob), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.CronJobList)(nil), (*batch.CronJobList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CronJobList_To_batch_CronJobList(a.(*batchv1.CronJobList), b.(*batch.CronJobList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.CronJobList)(nil), (*batchv1.CronJobList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_CronJobList_To_v1_CronJobList(a.(*batch.CronJobList), b.(*batchv1.CronJobList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.CronJobSpec)(nil), (*batch.CronJobSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CronJobSpec_To_batch_CronJobSpec(a.(*batchv1.CronJobSpec), b.(*batch.CronJobSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.CronJobSpec)(nil), (*batchv1.CronJobSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_CronJobSpec_To_v1_CronJobSpec(a.(*batch.CronJobSpec), b.(*batchv1.CronJobSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.CronJobStatus)(nil), (*batch.CronJobStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CronJobStatus_To_batch_CronJobStatus(a.(*batchv1.CronJobStatus), b.(*batch.CronJobStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.CronJobStatus)(nil), (*batchv1.CronJobStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_CronJobStatus_To_v1_CronJobStatus(a.(*batch.CronJobStatus), b.(*batchv1.CronJobStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.Job)(nil), (*batch.Job)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Job_To_batch_Job(a.(*batchv1.Job), b.(*batch.Job), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.Job)(nil), (*batchv1.Job)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_Job_To_v1_Job(a.(*batch.Job), b.(*batchv1.Job), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.JobCondition)(nil), (*batch.JobCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_JobCondition_To_batch_JobCondition(a.(*batchv1.JobCondition), b.(*batch.JobCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.JobCondition)(nil), (*batchv1.JobCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_JobCondition_To_v1_JobCondition(a.(*batch.JobCondition), b.(*batchv1.JobCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.JobList)(nil), (*batch.JobList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_JobList_To_batch_JobList(a.(*batchv1.JobList), b.(*batch.JobList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.JobList)(nil), (*batchv1.JobList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_JobList_To_v1_JobList(a.(*batch.JobList), b.(*batchv1.JobList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.JobStatus)(nil), (*batch.JobStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_JobStatus_To_batch_JobStatus(a.(*batchv1.JobStatus), b.(*batch.JobStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.JobStatus)(nil), (*batchv1.JobStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_JobStatus_To_v1_JobStatus(a.(*batch.JobStatus), b.(*batchv1.JobStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.JobTemplateSpec)(nil), (*batch.JobTemplateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_JobTemplateSpec_To_batch_JobTemplateSpec(a.(*batchv1.JobTemplateSpec), b.(*batch.JobTemplateSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.JobTemplateSpec)(nil), (*batchv1.JobTemplateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_JobTemplateSpec_To_v1_JobTemplateSpec(a.(*batch.JobTemplateSpec), b.(*batchv1.JobTemplateSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.PodFailurePolicy)(nil), (*batch.PodFailurePolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodFailurePolicy_To_batch_PodFailurePolicy(a.(*batchv1.PodFailurePolicy), b.(*batch.PodFailurePolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.PodFailurePolicy)(nil), (*batchv1.PodFailurePolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_PodFailurePolicy_To_v1_PodFailurePolicy(a.(*batch.PodFailurePolicy), b.(*batchv1.PodFailurePolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.PodFailurePolicyOnExitCodesRequirement)(nil), (*batch.PodFailurePolicyOnExitCodesRequirement)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodFailurePolicyOnExitCodesRequirement_To_batch_PodFailurePolicyOnExitCodesRequirement(a.(*batchv1.PodFailurePolicyOnExitCodesRequirement), b.(*batch.PodFailurePolicyOnExitCodesRequirement), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.PodFailurePolicyOnExitCodesRequirement)(nil), (*batchv1.PodFailurePolicyOnExitCodesRequirement)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_PodFailurePolicyOnExitCodesRequirement_To_v1_PodFailurePolicyOnExitCodesRequirement(a.(*batch.PodFailurePolicyOnExitCodesRequirement), b.(*batchv1.PodFailurePolicyOnExitCodesRequirement), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.PodFailurePolicyOnPodConditionsPattern)(nil), (*batch.PodFailurePolicyOnPodConditionsPattern)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodFailurePolicyOnPodConditionsPattern_To_batch_PodFailurePolicyOnPodConditionsPattern(a.(*batchv1.PodFailurePolicyOnPodConditionsPattern), b.(*batch.PodFailurePolicyOnPodConditionsPattern), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.PodFailurePolicyOnPodConditionsPattern)(nil), (*batchv1.PodFailurePolicyOnPodConditionsPattern)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_PodFailurePolicyOnPodConditionsPattern_To_v1_PodFailurePolicyOnPodConditionsPattern(a.(*batch.PodFailurePolicyOnPodConditionsPattern), b.(*batchv1.PodFailurePolicyOnPodConditionsPattern), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.PodFailurePolicyRule)(nil), (*batch.PodFailurePolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodFailurePolicyRule_To_batch_PodFailurePolicyRule(a.(*batchv1.PodFailurePolicyRule), b.(*batch.PodFailurePolicyRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.PodFailurePolicyRule)(nil), (*batchv1.PodFailurePolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_PodFailurePolicyRule_To_v1_PodFailurePolicyRule(a.(*batch.PodFailurePolicyRule), b.(*batchv1.PodFailurePolicyRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.SuccessPolicy)(nil), (*batch.SuccessPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SuccessPolicy_To_batch_SuccessPolicy(a.(*batchv1.SuccessPolicy), b.(*batch.SuccessPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.SuccessPolicy)(nil), (*batchv1.SuccessPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_SuccessPolicy_To_v1_SuccessPolicy(a.(*batch.SuccessPolicy), b.(*batchv1.SuccessPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.SuccessPolicyRule)(nil), (*batch.SuccessPolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SuccessPolicyRule_To_batch_SuccessPolicyRule(a.(*batchv1.SuccessPolicyRule), b.(*batch.SuccessPolicyRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.SuccessPolicyRule)(nil), (*batchv1.SuccessPolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_SuccessPolicyRule_To_v1_SuccessPolicyRule(a.(*batch.SuccessPolicyRule), b.(*batchv1.SuccessPolicyRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1.UncountedTerminatedPods)(nil), (*batch.UncountedTerminatedPods)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_UncountedTerminatedPods_To_batch_UncountedTerminatedPods(a.(*batchv1.UncountedTerminatedPods), b.(*batch.UncountedTerminatedPods), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.UncountedTerminatedPods)(nil), (*batchv1.UncountedTerminatedPods)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_UncountedTerminatedPods_To_v1_UncountedTerminatedPods(a.(*batch.UncountedTerminatedPods), b.(*batchv1.UncountedTerminatedPods), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*batch.JobSpec)(nil), (*batchv1.JobSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_JobSpec_To_v1_JobSpec(a.(*batch.JobSpec), b.(*batchv1.JobSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*batchv1.JobSpec)(nil), (*batch.JobSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_JobSpec_To_batch_JobSpec(a.(*batchv1.JobSpec), b.(*batch.JobSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_CronJob_To_batch_CronJob(in *batchv1.CronJob, out *batch.CronJob, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_CronJobSpec_To_batch_CronJobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_CronJobStatus_To_batch_CronJobStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_CronJob_To_batch_CronJob is an autogenerated conversion function.
func Convert_v1_CronJob_To_batch_CronJob(in *batchv1.CronJob, out *batch.CronJob, s conversion.Scope) error {
        return autoConvert_v1_CronJob_To_batch_CronJob(in, out, s)
}

func autoConvert_batch_CronJob_To_v1_CronJob(in *batch.CronJob, out *batchv1.CronJob, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_batch_CronJobSpec_To_v1_CronJobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_batch_CronJobStatus_To_v1_CronJobStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_batch_CronJob_To_v1_CronJob is an autogenerated conversion function.
func Convert_batch_CronJob_To_v1_CronJob(in *batch.CronJob, out *batchv1.CronJob, s conversion.Scope) error {
        return autoConvert_batch_CronJob_To_v1_CronJob(in, out, s)
}

func autoConvert_v1_CronJobList_To_batch_CronJobList(in *batchv1.CronJobList, out *batch.CronJobList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]batch.CronJob, len(*in))
                for i := range *in {
                        if err := Convert_v1_CronJob_To_batch_CronJob(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_CronJobList_To_batch_CronJobList is an autogenerated conversion function.
func Convert_v1_CronJobList_To_batch_CronJobList(in *batchv1.CronJobList, out *batch.CronJobList, s conversion.Scope) error {
        return autoConvert_v1_CronJobList_To_batch_CronJobList(in, out, s)
}

func autoConvert_batch_CronJobList_To_v1_CronJobList(in *batch.CronJobList, out *batchv1.CronJobList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]batchv1.CronJob, len(*in))
                for i := range *in {
                        if err := Convert_batch_CronJob_To_v1_CronJob(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_batch_CronJobList_To_v1_CronJobList is an autogenerated conversion function.
func Convert_batch_CronJobList_To_v1_CronJobList(in *batch.CronJobList, out *batchv1.CronJobList, s conversion.Scope) error {
        return autoConvert_batch_CronJobList_To_v1_CronJobList(in, out, s)
}

func autoConvert_v1_CronJobSpec_To_batch_CronJobSpec(in *batchv1.CronJobSpec, out *batch.CronJobSpec, s conversion.Scope) error {
        out.Schedule = in.Schedule
        out.TimeZone = (*string)(unsafe.Pointer(in.TimeZone))
        out.StartingDeadlineSeconds = (*int64)(unsafe.Pointer(in.StartingDeadlineSeconds))
        out.ConcurrencyPolicy = batch.ConcurrencyPolicy(in.ConcurrencyPolicy)
        out.Suspend = (*bool)(unsafe.Pointer(in.Suspend))
        if err := Convert_v1_JobTemplateSpec_To_batch_JobTemplateSpec(&in.JobTemplate, &out.JobTemplate, s); err != nil {
                return err
        }
        out.SuccessfulJobsHistoryLimit = (*int32)(unsafe.Pointer(in.SuccessfulJobsHistoryLimit))
        out.FailedJobsHistoryLimit = (*int32)(unsafe.Pointer(in.FailedJobsHistoryLimit))
        return nil
}

// Convert_v1_CronJobSpec_To_batch_CronJobSpec is an autogenerated conversion function.
func Convert_v1_CronJobSpec_To_batch_CronJobSpec(in *batchv1.CronJobSpec, out *batch.CronJobSpec, s conversion.Scope) error {
        return autoConvert_v1_CronJobSpec_To_batch_CronJobSpec(in, out, s)
}

func autoConvert_batch_CronJobSpec_To_v1_CronJobSpec(in *batch.CronJobSpec, out *batchv1.CronJobSpec, s conversion.Scope) error {
        out.Schedule = in.Schedule
        out.TimeZone = (*string)(unsafe.Pointer(in.TimeZone))
        out.StartingDeadlineSeconds = (*int64)(unsafe.Pointer(in.StartingDeadlineSeconds))
        out.ConcurrencyPolicy = batchv1.ConcurrencyPolicy(in.ConcurrencyPolicy)
        out.Suspend = (*bool)(unsafe.Pointer(in.Suspend))
        if err := Convert_batch_JobTemplateSpec_To_v1_JobTemplateSpec(&in.JobTemplate, &out.JobTemplate, s); err != nil {
                return err
        }
        out.SuccessfulJobsHistoryLimit = (*int32)(unsafe.Pointer(in.SuccessfulJobsHistoryLimit))
        out.FailedJobsHistoryLimit = (*int32)(unsafe.Pointer(in.FailedJobsHistoryLimit))
        return nil
}

// Convert_batch_CronJobSpec_To_v1_CronJobSpec is an autogenerated conversion function.
func Convert_batch_CronJobSpec_To_v1_CronJobSpec(in *batch.CronJobSpec, out *batchv1.CronJobSpec, s conversion.Scope) error {
        return autoConvert_batch_CronJobSpec_To_v1_CronJobSpec(in, out, s)
}

func autoConvert_v1_CronJobStatus_To_batch_CronJobStatus(in *batchv1.CronJobStatus, out *batch.CronJobStatus, s conversion.Scope) error {
        out.Active = *(*[]core.ObjectReference)(unsafe.Pointer(&in.Active))
        out.LastScheduleTime = (*metav1.Time)(unsafe.Pointer(in.LastScheduleTime))
        out.LastSuccessfulTime = (*metav1.Time)(unsafe.Pointer(in.LastSuccessfulTime))
        return nil
}

// Convert_v1_CronJobStatus_To_batch_CronJobStatus is an autogenerated conversion function.
func Convert_v1_CronJobStatus_To_batch_CronJobStatus(in *batchv1.CronJobStatus, out *batch.CronJobStatus, s conversion.Scope) error {
        return autoConvert_v1_CronJobStatus_To_batch_CronJobStatus(in, out, s)
}

func autoConvert_batch_CronJobStatus_To_v1_CronJobStatus(in *batch.CronJobStatus, out *batchv1.CronJobStatus, s conversion.Scope) error {
        out.Active = *(*[]corev1.ObjectReference)(unsafe.Pointer(&in.Active))
        out.LastScheduleTime = (*metav1.Time)(unsafe.Pointer(in.LastScheduleTime))
        out.LastSuccessfulTime = (*metav1.Time)(unsafe.Pointer(in.LastSuccessfulTime))
        return nil
}

// Convert_batch_CronJobStatus_To_v1_CronJobStatus is an autogenerated conversion function.
func Convert_batch_CronJobStatus_To_v1_CronJobStatus(in *batch.CronJobStatus, out *batchv1.CronJobStatus, s conversion.Scope) error {
        return autoConvert_batch_CronJobStatus_To_v1_CronJobStatus(in, out, s)
}

func autoConvert_v1_Job_To_batch_Job(in *batchv1.Job, out *batch.Job, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_JobStatus_To_batch_JobStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_Job_To_batch_Job is an autogenerated conversion function.
func Convert_v1_Job_To_batch_Job(in *batchv1.Job, out *batch.Job, s conversion.Scope) error {
        return autoConvert_v1_Job_To_batch_Job(in, out, s)
}

func autoConvert_batch_Job_To_v1_Job(in *batch.Job, out *batchv1.Job, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_batch_JobSpec_To_v1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_batch_JobStatus_To_v1_JobStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_batch_Job_To_v1_Job is an autogenerated conversion function.
func Convert_batch_Job_To_v1_Job(in *batch.Job, out *batchv1.Job, s conversion.Scope) error {
        return autoConvert_batch_Job_To_v1_Job(in, out, s)
}

func autoConvert_v1_JobCondition_To_batch_JobCondition(in *batchv1.JobCondition, out *batch.JobCondition, s conversion.Scope) error {
        out.Type = batch.JobConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastProbeTime = in.LastProbeTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_JobCondition_To_batch_JobCondition is an autogenerated conversion function.
func Convert_v1_JobCondition_To_batch_JobCondition(in *batchv1.JobCondition, out *batch.JobCondition, s conversion.Scope) error {
        return autoConvert_v1_JobCondition_To_batch_JobCondition(in, out, s)
}

func autoConvert_batch_JobCondition_To_v1_JobCondition(in *batch.JobCondition, out *batchv1.JobCondition, s conversion.Scope) error {
        out.Type = batchv1.JobConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastProbeTime = in.LastProbeTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_batch_JobCondition_To_v1_JobCondition is an autogenerated conversion function.
func Convert_batch_JobCondition_To_v1_JobCondition(in *batch.JobCondition, out *batchv1.JobCondition, s conversion.Scope) error {
        return autoConvert_batch_JobCondition_To_v1_JobCondition(in, out, s)
}

func autoConvert_v1_JobList_To_batch_JobList(in *batchv1.JobList, out *batch.JobList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]batch.Job, len(*in))
                for i := range *in {
                        if err := Convert_v1_Job_To_batch_Job(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_JobList_To_batch_JobList is an autogenerated conversion function.
func Convert_v1_JobList_To_batch_JobList(in *batchv1.JobList, out *batch.JobList, s conversion.Scope) error {
        return autoConvert_v1_JobList_To_batch_JobList(in, out, s)
}

func autoConvert_batch_JobList_To_v1_JobList(in *batch.JobList, out *batchv1.JobList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]batchv1.Job, len(*in))
                for i := range *in {
                        if err := Convert_batch_Job_To_v1_Job(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_batch_JobList_To_v1_JobList is an autogenerated conversion function.
func Convert_batch_JobList_To_v1_JobList(in *batch.JobList, out *batchv1.JobList, s conversion.Scope) error {
        return autoConvert_batch_JobList_To_v1_JobList(in, out, s)
}

func autoConvert_v1_JobSpec_To_batch_JobSpec(in *batchv1.JobSpec, out *batch.JobSpec, s conversion.Scope) error {
        out.Parallelism = (*int32)(unsafe.Pointer(in.Parallelism))
        out.Completions = (*int32)(unsafe.Pointer(in.Completions))
        out.ActiveDeadlineSeconds = (*int64)(unsafe.Pointer(in.ActiveDeadlineSeconds))
        out.PodFailurePolicy = (*batch.PodFailurePolicy)(unsafe.Pointer(in.PodFailurePolicy))
        out.SuccessPolicy = (*batch.SuccessPolicy)(unsafe.Pointer(in.SuccessPolicy))
        out.BackoffLimit = (*int32)(unsafe.Pointer(in.BackoffLimit))
        out.BackoffLimitPerIndex = (*int32)(unsafe.Pointer(in.BackoffLimitPerIndex))
        out.MaxFailedIndexes = (*int32)(unsafe.Pointer(in.MaxFailedIndexes))
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        out.ManualSelector = (*bool)(unsafe.Pointer(in.ManualSelector))
        if err := apiscorev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        out.TTLSecondsAfterFinished = (*int32)(unsafe.Pointer(in.TTLSecondsAfterFinished))
        out.CompletionMode = (*batch.CompletionMode)(unsafe.Pointer(in.CompletionMode))
        out.Suspend = (*bool)(unsafe.Pointer(in.Suspend))
        out.PodReplacementPolicy = (*batch.PodReplacementPolicy)(unsafe.Pointer(in.PodReplacementPolicy))
        out.ManagedBy = (*string)(unsafe.Pointer(in.ManagedBy))
        return nil
}

func autoConvert_batch_JobSpec_To_v1_JobSpec(in *batch.JobSpec, out *batchv1.JobSpec, s conversion.Scope) error {
        out.Parallelism = (*int32)(unsafe.Pointer(in.Parallelism))
        out.Completions = (*int32)(unsafe.Pointer(in.Completions))
        out.PodFailurePolicy = (*batchv1.PodFailurePolicy)(unsafe.Pointer(in.PodFailurePolicy))
        out.SuccessPolicy = (*batchv1.SuccessPolicy)(unsafe.Pointer(in.SuccessPolicy))
        out.ActiveDeadlineSeconds = (*int64)(unsafe.Pointer(in.ActiveDeadlineSeconds))
        out.BackoffLimit = (*int32)(unsafe.Pointer(in.BackoffLimit))
        out.BackoffLimitPerIndex = (*int32)(unsafe.Pointer(in.BackoffLimitPerIndex))
        out.MaxFailedIndexes = (*int32)(unsafe.Pointer(in.MaxFailedIndexes))
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        out.ManualSelector = (*bool)(unsafe.Pointer(in.ManualSelector))
        if err := apiscorev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        out.TTLSecondsAfterFinished = (*int32)(unsafe.Pointer(in.TTLSecondsAfterFinished))
        out.CompletionMode = (*batchv1.CompletionMode)(unsafe.Pointer(in.CompletionMode))
        out.Suspend = (*bool)(unsafe.Pointer(in.Suspend))
        out.PodReplacementPolicy = (*batchv1.PodReplacementPolicy)(unsafe.Pointer(in.PodReplacementPolicy))
        out.ManagedBy = (*string)(unsafe.Pointer(in.ManagedBy))
        return nil
}

func autoConvert_v1_JobStatus_To_batch_JobStatus(in *batchv1.JobStatus, out *batch.JobStatus, s conversion.Scope) error {
        out.Conditions = *(*[]batch.JobCondition)(unsafe.Pointer(&in.Conditions))
        out.StartTime = (*metav1.Time)(unsafe.Pointer(in.StartTime))
        out.CompletionTime = (*metav1.Time)(unsafe.Pointer(in.CompletionTime))
        out.Active = in.Active
        out.Succeeded = in.Succeeded
        out.Failed = in.Failed
        out.Terminating = (*int32)(unsafe.Pointer(in.Terminating))
        out.CompletedIndexes = in.CompletedIndexes
        out.FailedIndexes = (*string)(unsafe.Pointer(in.FailedIndexes))
        out.UncountedTerminatedPods = (*batch.UncountedTerminatedPods)(unsafe.Pointer(in.UncountedTerminatedPods))
        out.Ready = (*int32)(unsafe.Pointer(in.Ready))
        return nil
}

// Convert_v1_JobStatus_To_batch_JobStatus is an autogenerated conversion function.
func Convert_v1_JobStatus_To_batch_JobStatus(in *batchv1.JobStatus, out *batch.JobStatus, s conversion.Scope) error {
        return autoConvert_v1_JobStatus_To_batch_JobStatus(in, out, s)
}

func autoConvert_batch_JobStatus_To_v1_JobStatus(in *batch.JobStatus, out *batchv1.JobStatus, s conversion.Scope) error {
        out.Conditions = *(*[]batchv1.JobCondition)(unsafe.Pointer(&in.Conditions))
        out.StartTime = (*metav1.Time)(unsafe.Pointer(in.StartTime))
        out.CompletionTime = (*metav1.Time)(unsafe.Pointer(in.CompletionTime))
        out.Active = in.Active
        out.Terminating = (*int32)(unsafe.Pointer(in.Terminating))
        out.Ready = (*int32)(unsafe.Pointer(in.Ready))
        out.Succeeded = in.Succeeded
        out.Failed = in.Failed
        out.CompletedIndexes = in.CompletedIndexes
        out.FailedIndexes = (*string)(unsafe.Pointer(in.FailedIndexes))
        out.UncountedTerminatedPods = (*batchv1.UncountedTerminatedPods)(unsafe.Pointer(in.UncountedTerminatedPods))
        return nil
}

// Convert_batch_JobStatus_To_v1_JobStatus is an autogenerated conversion function.
func Convert_batch_JobStatus_To_v1_JobStatus(in *batch.JobStatus, out *batchv1.JobStatus, s conversion.Scope) error {
        return autoConvert_batch_JobStatus_To_v1_JobStatus(in, out, s)
}

func autoConvert_v1_JobTemplateSpec_To_batch_JobTemplateSpec(in *batchv1.JobTemplateSpec, out *batch.JobTemplateSpec, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_JobTemplateSpec_To_batch_JobTemplateSpec is an autogenerated conversion function.
func Convert_v1_JobTemplateSpec_To_batch_JobTemplateSpec(in *batchv1.JobTemplateSpec, out *batch.JobTemplateSpec, s conversion.Scope) error {
        return autoConvert_v1_JobTemplateSpec_To_batch_JobTemplateSpec(in, out, s)
}

func autoConvert_batch_JobTemplateSpec_To_v1_JobTemplateSpec(in *batch.JobTemplateSpec, out *batchv1.JobTemplateSpec, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_batch_JobSpec_To_v1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_batch_JobTemplateSpec_To_v1_JobTemplateSpec is an autogenerated conversion function.
func Convert_batch_JobTemplateSpec_To_v1_JobTemplateSpec(in *batch.JobTemplateSpec, out *batchv1.JobTemplateSpec, s conversion.Scope) error {
        return autoConvert_batch_JobTemplateSpec_To_v1_JobTemplateSpec(in, out, s)
}

func autoConvert_v1_PodFailurePolicy_To_batch_PodFailurePolicy(in *batchv1.PodFailurePolicy, out *batch.PodFailurePolicy, s conversion.Scope) error {
        out.Rules = *(*[]batch.PodFailurePolicyRule)(unsafe.Pointer(&in.Rules))
        return nil
}

// Convert_v1_PodFailurePolicy_To_batch_PodFailurePolicy is an autogenerated conversion function.
func Convert_v1_PodFailurePolicy_To_batch_PodFailurePolicy(in *batchv1.PodFailurePolicy, out *batch.PodFailurePolicy, s conversion.Scope) error {
        return autoConvert_v1_PodFailurePolicy_To_batch_PodFailurePolicy(in, out, s)
}

func autoConvert_batch_PodFailurePolicy_To_v1_PodFailurePolicy(in *batch.PodFailurePolicy, out *batchv1.PodFailurePolicy, s conversion.Scope) error {
        out.Rules = *(*[]batchv1.PodFailurePolicyRule)(unsafe.Pointer(&in.Rules))
        return nil
}

// Convert_batch_PodFailurePolicy_To_v1_PodFailurePolicy is an autogenerated conversion function.
func Convert_batch_PodFailurePolicy_To_v1_PodFailurePolicy(in *batch.PodFailurePolicy, out *batchv1.PodFailurePolicy, s conversion.Scope) error {
        return autoConvert_batch_PodFailurePolicy_To_v1_PodFailurePolicy(in, out, s)
}

func autoConvert_v1_PodFailurePolicyOnExitCodesRequirement_To_batch_PodFailurePolicyOnExitCodesRequirement(in *batchv1.PodFailurePolicyOnExitCodesRequirement, out *batch.PodFailurePolicyOnExitCodesRequirement, s conversion.Scope) error {
        out.ContainerName = (*string)(unsafe.Pointer(in.ContainerName))
        out.Operator = batch.PodFailurePolicyOnExitCodesOperator(in.Operator)
        out.Values = *(*[]int32)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_v1_PodFailurePolicyOnExitCodesRequirement_To_batch_PodFailurePolicyOnExitCodesRequirement is an autogenerated conversion function.
func Convert_v1_PodFailurePolicyOnExitCodesRequirement_To_batch_PodFailurePolicyOnExitCodesRequirement(in *batchv1.PodFailurePolicyOnExitCodesRequirement, out *batch.PodFailurePolicyOnExitCodesRequirement, s conversion.Scope) error {
        return autoConvert_v1_PodFailurePolicyOnExitCodesRequirement_To_batch_PodFailurePolicyOnExitCodesRequirement(in, out, s)
}

func autoConvert_batch_PodFailurePolicyOnExitCodesRequirement_To_v1_PodFailurePolicyOnExitCodesRequirement(in *batch.PodFailurePolicyOnExitCodesRequirement, out *batchv1.PodFailurePolicyOnExitCodesRequirement, s conversion.Scope) error {
        out.ContainerName = (*string)(unsafe.Pointer(in.ContainerName))
        out.Operator = batchv1.PodFailurePolicyOnExitCodesOperator(in.Operator)
        out.Values = *(*[]int32)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_batch_PodFailurePolicyOnExitCodesRequirement_To_v1_PodFailurePolicyOnExitCodesRequirement is an autogenerated conversion function.
func Convert_batch_PodFailurePolicyOnExitCodesRequirement_To_v1_PodFailurePolicyOnExitCodesRequirement(in *batch.PodFailurePolicyOnExitCodesRequirement, out *batchv1.PodFailurePolicyOnExitCodesRequirement, s conversion.Scope) error {
        return autoConvert_batch_PodFailurePolicyOnExitCodesRequirement_To_v1_PodFailurePolicyOnExitCodesRequirement(in, out, s)
}

func autoConvert_v1_PodFailurePolicyOnPodConditionsPattern_To_batch_PodFailurePolicyOnPodConditionsPattern(in *batchv1.PodFailurePolicyOnPodConditionsPattern, out *batch.PodFailurePolicyOnPodConditionsPattern, s conversion.Scope) error {
        out.Type = core.PodConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        return nil
}

// Convert_v1_PodFailurePolicyOnPodConditionsPattern_To_batch_PodFailurePolicyOnPodConditionsPattern is an autogenerated conversion function.
func Convert_v1_PodFailurePolicyOnPodConditionsPattern_To_batch_PodFailurePolicyOnPodConditionsPattern(in *batchv1.PodFailurePolicyOnPodConditionsPattern, out *batch.PodFailurePolicyOnPodConditionsPattern, s conversion.Scope) error {
        return autoConvert_v1_PodFailurePolicyOnPodConditionsPattern_To_batch_PodFailurePolicyOnPodConditionsPattern(in, out, s)
}

func autoConvert_batch_PodFailurePolicyOnPodConditionsPattern_To_v1_PodFailurePolicyOnPodConditionsPattern(in *batch.PodFailurePolicyOnPodConditionsPattern, out *batchv1.PodFailurePolicyOnPodConditionsPattern, s conversion.Scope) error {
        out.Type = corev1.PodConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        return nil
}

// Convert_batch_PodFailurePolicyOnPodConditionsPattern_To_v1_PodFailurePolicyOnPodConditionsPattern is an autogenerated conversion function.
func Convert_batch_PodFailurePolicyOnPodConditionsPattern_To_v1_PodFailurePolicyOnPodConditionsPattern(in *batch.PodFailurePolicyOnPodConditionsPattern, out *batchv1.PodFailurePolicyOnPodConditionsPattern, s conversion.Scope) error {
        return autoConvert_batch_PodFailurePolicyOnPodConditionsPattern_To_v1_PodFailurePolicyOnPodConditionsPattern(in, out, s)
}

func autoConvert_v1_PodFailurePolicyRule_To_batch_PodFailurePolicyRule(in *batchv1.PodFailurePolicyRule, out *batch.PodFailurePolicyRule, s conversion.Scope) error {
        out.Action = batch.PodFailurePolicyAction(in.Action)
        out.OnExitCodes = (*batch.PodFailurePolicyOnExitCodesRequirement)(unsafe.Pointer(in.OnExitCodes))
        out.OnPodConditions = *(*[]batch.PodFailurePolicyOnPodConditionsPattern)(unsafe.Pointer(&in.OnPodConditions))
        return nil
}

// Convert_v1_PodFailurePolicyRule_To_batch_PodFailurePolicyRule is an autogenerated conversion function.
func Convert_v1_PodFailurePolicyRule_To_batch_PodFailurePolicyRule(in *batchv1.PodFailurePolicyRule, out *batch.PodFailurePolicyRule, s conversion.Scope) error {
        return autoConvert_v1_PodFailurePolicyRule_To_batch_PodFailurePolicyRule(in, out, s)
}

func autoConvert_batch_PodFailurePolicyRule_To_v1_PodFailurePolicyRule(in *batch.PodFailurePolicyRule, out *batchv1.PodFailurePolicyRule, s conversion.Scope) error {
        out.Action = batchv1.PodFailurePolicyAction(in.Action)
        out.OnExitCodes = (*batchv1.PodFailurePolicyOnExitCodesRequirement)(unsafe.Pointer(in.OnExitCodes))
        out.OnPodConditions = *(*[]batchv1.PodFailurePolicyOnPodConditionsPattern)(unsafe.Pointer(&in.OnPodConditions))
        return nil
}

// Convert_batch_PodFailurePolicyRule_To_v1_PodFailurePolicyRule is an autogenerated conversion function.
func Convert_batch_PodFailurePolicyRule_To_v1_PodFailurePolicyRule(in *batch.PodFailurePolicyRule, out *batchv1.PodFailurePolicyRule, s conversion.Scope) error {
        return autoConvert_batch_PodFailurePolicyRule_To_v1_PodFailurePolicyRule(in, out, s)
}

func autoConvert_v1_SuccessPolicy_To_batch_SuccessPolicy(in *batchv1.SuccessPolicy, out *batch.SuccessPolicy, s conversion.Scope) error {
        out.Rules = *(*[]batch.SuccessPolicyRule)(unsafe.Pointer(&in.Rules))
        return nil
}

// Convert_v1_SuccessPolicy_To_batch_SuccessPolicy is an autogenerated conversion function.
func Convert_v1_SuccessPolicy_To_batch_SuccessPolicy(in *batchv1.SuccessPolicy, out *batch.SuccessPolicy, s conversion.Scope) error {
        return autoConvert_v1_SuccessPolicy_To_batch_SuccessPolicy(in, out, s)
}

func autoConvert_batch_SuccessPolicy_To_v1_SuccessPolicy(in *batch.SuccessPolicy, out *batchv1.SuccessPolicy, s conversion.Scope) error {
        out.Rules = *(*[]batchv1.SuccessPolicyRule)(unsafe.Pointer(&in.Rules))
        return nil
}

// Convert_batch_SuccessPolicy_To_v1_SuccessPolicy is an autogenerated conversion function.
func Convert_batch_SuccessPolicy_To_v1_SuccessPolicy(in *batch.SuccessPolicy, out *batchv1.SuccessPolicy, s conversion.Scope) error {
        return autoConvert_batch_SuccessPolicy_To_v1_SuccessPolicy(in, out, s)
}

func autoConvert_v1_SuccessPolicyRule_To_batch_SuccessPolicyRule(in *batchv1.SuccessPolicyRule, out *batch.SuccessPolicyRule, s conversion.Scope) error {
        out.SucceededIndexes = (*string)(unsafe.Pointer(in.SucceededIndexes))
        out.SucceededCount = (*int32)(unsafe.Pointer(in.SucceededCount))
        return nil
}

// Convert_v1_SuccessPolicyRule_To_batch_SuccessPolicyRule is an autogenerated conversion function.
func Convert_v1_SuccessPolicyRule_To_batch_SuccessPolicyRule(in *batchv1.SuccessPolicyRule, out *batch.SuccessPolicyRule, s conversion.Scope) error {
        return autoConvert_v1_SuccessPolicyRule_To_batch_SuccessPolicyRule(in, out, s)
}

func autoConvert_batch_SuccessPolicyRule_To_v1_SuccessPolicyRule(in *batch.SuccessPolicyRule, out *batchv1.SuccessPolicyRule, s conversion.Scope) error {
        out.SucceededIndexes = (*string)(unsafe.Pointer(in.SucceededIndexes))
        out.SucceededCount = (*int32)(unsafe.Pointer(in.SucceededCount))
        return nil
}

// Convert_batch_SuccessPolicyRule_To_v1_SuccessPolicyRule is an autogenerated conversion function.
func Convert_batch_SuccessPolicyRule_To_v1_SuccessPolicyRule(in *batch.SuccessPolicyRule, out *batchv1.SuccessPolicyRule, s conversion.Scope) error {
        return autoConvert_batch_SuccessPolicyRule_To_v1_SuccessPolicyRule(in, out, s)
}

func autoConvert_v1_UncountedTerminatedPods_To_batch_UncountedTerminatedPods(in *batchv1.UncountedTerminatedPods, out *batch.UncountedTerminatedPods, s conversion.Scope) error {
        out.Succeeded = *(*[]types.UID)(unsafe.Pointer(&in.Succeeded))
        out.Failed = *(*[]types.UID)(unsafe.Pointer(&in.Failed))
        return nil
}

// Convert_v1_UncountedTerminatedPods_To_batch_UncountedTerminatedPods is an autogenerated conversion function.
func Convert_v1_UncountedTerminatedPods_To_batch_UncountedTerminatedPods(in *batchv1.UncountedTerminatedPods, out *batch.UncountedTerminatedPods, s conversion.Scope) error {
        return autoConvert_v1_UncountedTerminatedPods_To_batch_UncountedTerminatedPods(in, out, s)
}

func autoConvert_batch_UncountedTerminatedPods_To_v1_UncountedTerminatedPods(in *batch.UncountedTerminatedPods, out *batchv1.UncountedTerminatedPods, s conversion.Scope) error {
        out.Succeeded = *(*[]types.UID)(unsafe.Pointer(&in.Succeeded))
        out.Failed = *(*[]types.UID)(unsafe.Pointer(&in.Failed))
        return nil
}

// Convert_batch_UncountedTerminatedPods_To_v1_UncountedTerminatedPods is an autogenerated conversion function.
func Convert_batch_UncountedTerminatedPods_To_v1_UncountedTerminatedPods(in *batch.UncountedTerminatedPods, out *batchv1.UncountedTerminatedPods, s conversion.Scope) error {
        return autoConvert_batch_UncountedTerminatedPods_To_v1_UncountedTerminatedPods(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        batchv1 "k8s.io/api/batch/v1"
        corev1 "k8s.io/api/core/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        apiscorev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&batchv1.CronJob{}, func(obj interface{}) { SetObjectDefaults_CronJob(obj.(*batchv1.CronJob)) })
        scheme.AddTypeDefaultingFunc(&batchv1.CronJobList{}, func(obj interface{}) { SetObjectDefaults_CronJobList(obj.(*batchv1.CronJobList)) })
        scheme.AddTypeDefaultingFunc(&batchv1.Job{}, func(obj interface{}) { SetObjectDefaults_Job(obj.(*batchv1.Job)) })
        scheme.AddTypeDefaultingFunc(&batchv1.JobList{}, func(obj interface{}) { SetObjectDefaults_JobList(obj.(*batchv1.JobList)) })
        return nil
}

func SetObjectDefaults_CronJob(in *batchv1.CronJob) {
        SetDefaults_CronJob(in)
        if in.Spec.JobTemplate.Spec.PodFailurePolicy != nil {
                for i := range in.Spec.JobTemplate.Spec.PodFailurePolicy.Rules {
                        a := &in.Spec.JobTemplate.Spec.PodFailurePolicy.Rules[i]
                        for j := range a.OnPodConditions {
                                b := &a.OnPodConditions[j]
                                SetDefaults_PodFailurePolicyOnPodConditionsPattern(b)
                        }
                }
        }
        apiscorev1.SetDefaults_PodSpec(&in.Spec.JobTemplate.Spec.Template.Spec)
        for i := range in.Spec.JobTemplate.Spec.Template.Spec.Volumes {
                a := &in.Spec.JobTemplate.Spec.Template.Spec.Volumes[i]
                apiscorev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        apiscorev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        apiscorev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        apiscorev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        apiscorev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        apiscorev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        apiscorev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        apiscorev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                apiscorev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.JobTemplate.Spec.Template.Spec.InitContainers {
                a := &in.Spec.JobTemplate.Spec.Template.Spec.InitContainers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.JobTemplate.Spec.Template.Spec.Containers {
                a := &in.Spec.JobTemplate.Spec.Template.Spec.Containers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.JobTemplate.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.JobTemplate.Spec.Template.Spec.EphemeralContainers[i]
                apiscorev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        apiscorev1.SetDefaults_ResourceList(&in.Spec.JobTemplate.Spec.Template.Spec.Overhead)
        if in.Spec.JobTemplate.Spec.Template.Spec.Resources != nil {
                apiscorev1.SetDefaults_ResourceList(&in.Spec.JobTemplate.Spec.Template.Spec.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&in.Spec.JobTemplate.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_CronJobList(in *batchv1.CronJobList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_CronJob(a)
        }
}

func SetObjectDefaults_Job(in *batchv1.Job) {
        SetDefaults_Job(in)
        if in.Spec.PodFailurePolicy != nil {
                for i := range in.Spec.PodFailurePolicy.Rules {
                        a := &in.Spec.PodFailurePolicy.Rules[i]
                        for j := range a.OnPodConditions {
                                b := &a.OnPodConditions[j]
                                SetDefaults_PodFailurePolicyOnPodConditionsPattern(b)
                        }
                }
        }
        apiscorev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                apiscorev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        apiscorev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        apiscorev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        apiscorev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        apiscorev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        apiscorev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        apiscorev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        apiscorev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                apiscorev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                apiscorev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                apiscorev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                apiscorev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        apiscorev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        apiscorev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        apiscorev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                apiscorev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_JobList(in *batchv1.JobList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Job(a)
        }
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "fmt"

        "k8s.io/apimachinery/pkg/runtime"
)

func addConversionFuncs(scheme *runtime.Scheme) error {
        var err error
        // Add field label conversions for kinds having selectable nothing but ObjectMeta fields.
        for _, k := range []string{"Job", "JobTemplate", "CronJob"} {
                kind := k // don't close over range variables
                err = scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind(kind),
                        func(label, value string) (string, string, error) {
                                switch label {
                                case "metadata.name", "metadata.namespace", "status.successful":
                                        return label, value, nil
                                default:
                                        return "", "", fmt.Errorf("field label %q not supported for %q", label, kind)
                                }
                        })
                if err != nil {
                        return err
                }
        }
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        batchv1beta1 "k8s.io/api/batch/v1beta1"
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_CronJob(obj *batchv1beta1.CronJob) {
        if obj.Spec.ConcurrencyPolicy == "" {
                obj.Spec.ConcurrencyPolicy = batchv1beta1.AllowConcurrent
        }
        if obj.Spec.Suspend == nil {
                obj.Spec.Suspend = new(bool)
        }
        if obj.Spec.SuccessfulJobsHistoryLimit == nil {
                obj.Spec.SuccessfulJobsHistoryLimit = new(int32)
                *obj.Spec.SuccessfulJobsHistoryLimit = 3
        }
        if obj.Spec.FailedJobsHistoryLimit == nil {
                obj.Spec.FailedJobsHistoryLimit = new(int32)
                *obj.Spec.FailedJobsHistoryLimit = 1
        }
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        batchv1beta1 "k8s.io/api/batch/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "batch"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &batchv1beta1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        batchv1beta1 "k8s.io/api/batch/v1beta1"
        corev1 "k8s.io/api/core/v1"
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        batch "k8s.io/kubernetes/pkg/apis/batch"
        batchv1 "k8s.io/kubernetes/pkg/apis/batch/v1"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*batchv1beta1.CronJob)(nil), (*batch.CronJob)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CronJob_To_batch_CronJob(a.(*batchv1beta1.CronJob), b.(*batch.CronJob), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.CronJob)(nil), (*batchv1beta1.CronJob)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_CronJob_To_v1beta1_CronJob(a.(*batch.CronJob), b.(*batchv1beta1.CronJob), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1beta1.CronJobList)(nil), (*batch.CronJobList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CronJobList_To_batch_CronJobList(a.(*batchv1beta1.CronJobList), b.(*batch.CronJobList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.CronJobList)(nil), (*batchv1beta1.CronJobList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_CronJobList_To_v1beta1_CronJobList(a.(*batch.CronJobList), b.(*batchv1beta1.CronJobList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1beta1.CronJobSpec)(nil), (*batch.CronJobSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CronJobSpec_To_batch_CronJobSpec(a.(*batchv1beta1.CronJobSpec), b.(*batch.CronJobSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.CronJobSpec)(nil), (*batchv1beta1.CronJobSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_CronJobSpec_To_v1beta1_CronJobSpec(a.(*batch.CronJobSpec), b.(*batchv1beta1.CronJobSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1beta1.CronJobStatus)(nil), (*batch.CronJobStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CronJobStatus_To_batch_CronJobStatus(a.(*batchv1beta1.CronJobStatus), b.(*batch.CronJobStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.CronJobStatus)(nil), (*batchv1beta1.CronJobStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_CronJobStatus_To_v1beta1_CronJobStatus(a.(*batch.CronJobStatus), b.(*batchv1beta1.CronJobStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batchv1beta1.JobTemplateSpec)(nil), (*batch.JobTemplateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_JobTemplateSpec_To_batch_JobTemplateSpec(a.(*batchv1beta1.JobTemplateSpec), b.(*batch.JobTemplateSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*batch.JobTemplateSpec)(nil), (*batchv1beta1.JobTemplateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_batch_JobTemplateSpec_To_v1beta1_JobTemplateSpec(a.(*batch.JobTemplateSpec), b.(*batchv1beta1.JobTemplateSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_CronJob_To_batch_CronJob(in *batchv1beta1.CronJob, out *batch.CronJob, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_CronJobSpec_To_batch_CronJobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_CronJobStatus_To_batch_CronJobStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_CronJob_To_batch_CronJob is an autogenerated conversion function.
func Convert_v1beta1_CronJob_To_batch_CronJob(in *batchv1beta1.CronJob, out *batch.CronJob, s conversion.Scope) error {
        return autoConvert_v1beta1_CronJob_To_batch_CronJob(in, out, s)
}

func autoConvert_batch_CronJob_To_v1beta1_CronJob(in *batch.CronJob, out *batchv1beta1.CronJob, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_batch_CronJobSpec_To_v1beta1_CronJobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_batch_CronJobStatus_To_v1beta1_CronJobStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_batch_CronJob_To_v1beta1_CronJob is an autogenerated conversion function.
func Convert_batch_CronJob_To_v1beta1_CronJob(in *batch.CronJob, out *batchv1beta1.CronJob, s conversion.Scope) error {
        return autoConvert_batch_CronJob_To_v1beta1_CronJob(in, out, s)
}

func autoConvert_v1beta1_CronJobList_To_batch_CronJobList(in *batchv1beta1.CronJobList, out *batch.CronJobList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]batch.CronJob, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_CronJob_To_batch_CronJob(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_CronJobList_To_batch_CronJobList is an autogenerated conversion function.
func Convert_v1beta1_CronJobList_To_batch_CronJobList(in *batchv1beta1.CronJobList, out *batch.CronJobList, s conversion.Scope) error {
        return autoConvert_v1beta1_CronJobList_To_batch_CronJobList(in, out, s)
}

func autoConvert_batch_CronJobList_To_v1beta1_CronJobList(in *batch.CronJobList, out *batchv1beta1.CronJobList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]batchv1beta1.CronJob, len(*in))
                for i := range *in {
                        if err := Convert_batch_CronJob_To_v1beta1_CronJob(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_batch_CronJobList_To_v1beta1_CronJobList is an autogenerated conversion function.
func Convert_batch_CronJobList_To_v1beta1_CronJobList(in *batch.CronJobList, out *batchv1beta1.CronJobList, s conversion.Scope) error {
        return autoConvert_batch_CronJobList_To_v1beta1_CronJobList(in, out, s)
}

func autoConvert_v1beta1_CronJobSpec_To_batch_CronJobSpec(in *batchv1beta1.CronJobSpec, out *batch.CronJobSpec, s conversion.Scope) error {
        out.Schedule = in.Schedule
        out.TimeZone = (*string)(unsafe.Pointer(in.TimeZone))
        out.StartingDeadlineSeconds = (*int64)(unsafe.Pointer(in.StartingDeadlineSeconds))
        out.ConcurrencyPolicy = batch.ConcurrencyPolicy(in.ConcurrencyPolicy)
        out.Suspend = (*bool)(unsafe.Pointer(in.Suspend))
        if err := Convert_v1beta1_JobTemplateSpec_To_batch_JobTemplateSpec(&in.JobTemplate, &out.JobTemplate, s); err != nil {
                return err
        }
        out.SuccessfulJobsHistoryLimit = (*int32)(unsafe.Pointer(in.SuccessfulJobsHistoryLimit))
        out.FailedJobsHistoryLimit = (*int32)(unsafe.Pointer(in.FailedJobsHistoryLimit))
        return nil
}

// Convert_v1beta1_CronJobSpec_To_batch_CronJobSpec is an autogenerated conversion function.
func Convert_v1beta1_CronJobSpec_To_batch_CronJobSpec(in *batchv1beta1.CronJobSpec, out *batch.CronJobSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_CronJobSpec_To_batch_CronJobSpec(in, out, s)
}

func autoConvert_batch_CronJobSpec_To_v1beta1_CronJobSpec(in *batch.CronJobSpec, out *batchv1beta1.CronJobSpec, s conversion.Scope) error {
        out.Schedule = in.Schedule
        out.TimeZone = (*string)(unsafe.Pointer(in.TimeZone))
        out.StartingDeadlineSeconds = (*int64)(unsafe.Pointer(in.StartingDeadlineSeconds))
        out.ConcurrencyPolicy = batchv1beta1.ConcurrencyPolicy(in.ConcurrencyPolicy)
        out.Suspend = (*bool)(unsafe.Pointer(in.Suspend))
        if err := Convert_batch_JobTemplateSpec_To_v1beta1_JobTemplateSpec(&in.JobTemplate, &out.JobTemplate, s); err != nil {
                return err
        }
        out.SuccessfulJobsHistoryLimit = (*int32)(unsafe.Pointer(in.SuccessfulJobsHistoryLimit))
        out.FailedJobsHistoryLimit = (*int32)(unsafe.Pointer(in.FailedJobsHistoryLimit))
        return nil
}

// Convert_batch_CronJobSpec_To_v1beta1_CronJobSpec is an autogenerated conversion function.
func Convert_batch_CronJobSpec_To_v1beta1_CronJobSpec(in *batch.CronJobSpec, out *batchv1beta1.CronJobSpec, s conversion.Scope) error {
        return autoConvert_batch_CronJobSpec_To_v1beta1_CronJobSpec(in, out, s)
}

func autoConvert_v1beta1_CronJobStatus_To_batch_CronJobStatus(in *batchv1beta1.CronJobStatus, out *batch.CronJobStatus, s conversion.Scope) error {
        out.Active = *(*[]core.ObjectReference)(unsafe.Pointer(&in.Active))
        out.LastScheduleTime = (*v1.Time)(unsafe.Pointer(in.LastScheduleTime))
        out.LastSuccessfulTime = (*v1.Time)(unsafe.Pointer(in.LastSuccessfulTime))
        return nil
}

// Convert_v1beta1_CronJobStatus_To_batch_CronJobStatus is an autogenerated conversion function.
func Convert_v1beta1_CronJobStatus_To_batch_CronJobStatus(in *batchv1beta1.CronJobStatus, out *batch.CronJobStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_CronJobStatus_To_batch_CronJobStatus(in, out, s)
}

func autoConvert_batch_CronJobStatus_To_v1beta1_CronJobStatus(in *batch.CronJobStatus, out *batchv1beta1.CronJobStatus, s conversion.Scope) error {
        out.Active = *(*[]corev1.ObjectReference)(unsafe.Pointer(&in.Active))
        out.LastScheduleTime = (*v1.Time)(unsafe.Pointer(in.LastScheduleTime))
        out.LastSuccessfulTime = (*v1.Time)(unsafe.Pointer(in.LastSuccessfulTime))
        return nil
}

// Convert_batch_CronJobStatus_To_v1beta1_CronJobStatus is an autogenerated conversion function.
func Convert_batch_CronJobStatus_To_v1beta1_CronJobStatus(in *batch.CronJobStatus, out *batchv1beta1.CronJobStatus, s conversion.Scope) error {
        return autoConvert_batch_CronJobStatus_To_v1beta1_CronJobStatus(in, out, s)
}

func autoConvert_v1beta1_JobTemplateSpec_To_batch_JobTemplateSpec(in *batchv1beta1.JobTemplateSpec, out *batch.JobTemplateSpec, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := batchv1.Convert_v1_JobSpec_To_batch_JobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_JobTemplateSpec_To_batch_JobTemplateSpec is an autogenerated conversion function.
func Convert_v1beta1_JobTemplateSpec_To_batch_JobTemplateSpec(in *batchv1beta1.JobTemplateSpec, out *batch.JobTemplateSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_JobTemplateSpec_To_batch_JobTemplateSpec(in, out, s)
}

func autoConvert_batch_JobTemplateSpec_To_v1beta1_JobTemplateSpec(in *batch.JobTemplateSpec, out *batchv1beta1.JobTemplateSpec, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := batchv1.Convert_batch_JobSpec_To_v1_JobSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_batch_JobTemplateSpec_To_v1beta1_JobTemplateSpec is an autogenerated conversion function.
func Convert_batch_JobTemplateSpec_To_v1beta1_JobTemplateSpec(in *batch.JobTemplateSpec, out *batchv1beta1.JobTemplateSpec, s conversion.Scope) error {
        return autoConvert_batch_JobTemplateSpec_To_v1beta1_JobTemplateSpec(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        batchv1beta1 "k8s.io/api/batch/v1beta1"
        v1 "k8s.io/api/core/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        batchv1 "k8s.io/kubernetes/pkg/apis/batch/v1"
        corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&batchv1beta1.CronJob{}, func(obj interface{}) { SetObjectDefaults_CronJob(obj.(*batchv1beta1.CronJob)) })
        scheme.AddTypeDefaultingFunc(&batchv1beta1.CronJobList{}, func(obj interface{}) { SetObjectDefaults_CronJobList(obj.(*batchv1beta1.CronJobList)) })
        return nil
}

func SetObjectDefaults_CronJob(in *batchv1beta1.CronJob) {
        SetDefaults_CronJob(in)
        if in.Spec.JobTemplate.Spec.PodFailurePolicy != nil {
                for i := range in.Spec.JobTemplate.Spec.PodFailurePolicy.Rules {
                        a := &in.Spec.JobTemplate.Spec.PodFailurePolicy.Rules[i]
                        for j := range a.OnPodConditions {
                                b := &a.OnPodConditions[j]
                                batchv1.SetDefaults_PodFailurePolicyOnPodConditionsPattern(b)
                        }
                }
        }
        corev1.SetDefaults_PodSpec(&in.Spec.JobTemplate.Spec.Template.Spec)
        for i := range in.Spec.JobTemplate.Spec.Template.Spec.Volumes {
                a := &in.Spec.JobTemplate.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.JobTemplate.Spec.Template.Spec.InitContainers {
                a := &in.Spec.JobTemplate.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.JobTemplate.Spec.Template.Spec.Containers {
                a := &in.Spec.JobTemplate.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.JobTemplate.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.JobTemplate.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.JobTemplate.Spec.Template.Spec.Overhead)
        if in.Spec.JobTemplate.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.JobTemplate.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.JobTemplate.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_CronJobList(in *batchv1beta1.CronJobList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_CronJob(a)
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package validation

import (
        "fmt"
        "regexp"
        "strconv"
        "strings"
        "time"

        "github.com/robfig/cron/v3"

        apiequality "k8s.io/apimachinery/pkg/api/equality"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        unversionedvalidation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/apimachinery/pkg/types"
        "k8s.io/apimachinery/pkg/util/sets"
        apimachineryvalidation "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
        "k8s.io/kubernetes/pkg/apis/batch"
        api "k8s.io/kubernetes/pkg/apis/core"
        apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
        "k8s.io/utils/ptr"
)

// maxParallelismForIndexJob is the maximum parallelism that an Indexed Job
// is allowed to have. This threshold allows to cap the length of
// .status.completedIndexes.
const maxParallelismForIndexedJob = 100000

// maxFailedIndexesForIndexedJob is the maximum number of failed indexes that
// an Indexed Job is allowed to have. This threshold allows to cap the length of
// .status.completedIndexes and .status.failedIndexes.
const maxFailedIndexesForIndexedJob = 100_000

const (
        completionsSoftLimit                    = 100_000
        parallelismLimitForHighCompletions      = 10_000
        maxFailedIndexesLimitForHighCompletions = 10_000

        // maximum number of rules in pod failure policy
        maxPodFailurePolicyRules = 20

        // maximum number of values for a OnExitCodes requirement in pod failure policy
        maxPodFailurePolicyOnExitCodesValues = 255

        // maximum number of patterns for a OnPodConditions requirement in pod failure policy
        maxPodFailurePolicyOnPodConditionsPatterns = 20

        // maximum length of the value of the managedBy field
        maxManagedByLength = 63

        // maximum length of succeededIndexes in JobSuccessPolicy.
        maxJobSuccessPolicySucceededIndexesLimit = 64 * 1024
        // maximum number of rules in successPolicy.
        maxSuccessPolicyRule = 20
)

var (
        supportedPodFailurePolicyActions = sets.New(
                batch.PodFailurePolicyActionCount,
                batch.PodFailurePolicyActionFailIndex,
                batch.PodFailurePolicyActionFailJob,
                batch.PodFailurePolicyActionIgnore)

        supportedPodFailurePolicyOnExitCodesOperator = sets.New(
                batch.PodFailurePolicyOnExitCodesOpIn,
                batch.PodFailurePolicyOnExitCodesOpNotIn)

        supportedPodFailurePolicyOnPodConditionsStatus = sets.New(
                api.ConditionFalse,
                api.ConditionTrue,
                api.ConditionUnknown)

        supportedPodReplacementPolicy = sets.New(
                batch.Failed,
                batch.TerminatingOrFailed)
)

// validateGeneratedSelector validates that the generated selector on a controller object match the controller object
// metadata, and the labels on the pod template are as generated.
//
// TODO: generalize for other controller objects that will follow the same pattern, such as ReplicaSet and DaemonSet, and
// move to new location.  Replace batch.Job with an interface.
func validateGeneratedSelector(obj *batch.Job, validateBatchLabels bool) field.ErrorList {
        allErrs := field.ErrorList{}
        if obj.Spec.ManualSelector != nil && *obj.Spec.ManualSelector {
                return allErrs
        }

        if obj.Spec.Selector == nil {
                return allErrs // This case should already have been checked in caller.  No need for more errors.
        }

        // If somehow uid was unset then we would get "controller-uid=" as the selector
        // which is bad.
        if obj.ObjectMeta.UID == "" {
                allErrs = append(allErrs, field.Required(field.NewPath("metadata").Child("uid"), ""))
        }

        // If selector generation was requested, then expected labels must be
        // present on pod template, and must match job's uid and name.  The
        // generated (not-manual) selectors/labels ensure no overlap with other
        // controllers.  The manual mode allows orphaning, adoption,
        // backward-compatibility, and experimentation with new
        // labeling/selection schemes.  Automatic selector generation should
        // have placed certain labels on the pod, but this could have failed if
        // the user added conflicting labels.  Validate that the expected
        // generated ones are there.
        allErrs = append(allErrs, apivalidation.ValidateHasLabel(obj.Spec.Template.ObjectMeta, field.NewPath("spec").Child("template").Child("metadata"), batch.LegacyControllerUidLabel, string(obj.UID))...)
        allErrs = append(allErrs, apivalidation.ValidateHasLabel(obj.Spec.Template.ObjectMeta, field.NewPath("spec").Child("template").Child("metadata"), batch.LegacyJobNameLabel, string(obj.Name))...)
        expectedLabels := make(map[string]string)
        if validateBatchLabels {
                allErrs = append(allErrs, apivalidation.ValidateHasLabel(obj.Spec.Template.ObjectMeta, field.NewPath("spec").Child("template").Child("metadata"), batch.ControllerUidLabel, string(obj.UID))...)
                allErrs = append(allErrs, apivalidation.ValidateHasLabel(obj.Spec.Template.ObjectMeta, field.NewPath("spec").Child("template").Child("metadata"), batch.JobNameLabel, string(obj.Name))...)
                expectedLabels[batch.ControllerUidLabel] = string(obj.UID)
                expectedLabels[batch.JobNameLabel] = string(obj.Name)
        }
        // Labels created by the Kubernetes project should have a Kubernetes prefix.
        // These labels are set due to legacy reasons.

        expectedLabels[batch.LegacyControllerUidLabel] = string(obj.UID)
        expectedLabels[batch.LegacyJobNameLabel] = string(obj.Name)
        // Whether manually or automatically generated, the selector of the job must match the pods it will produce.
        if selector, err := metav1.LabelSelectorAsSelector(obj.Spec.Selector); err == nil {
                if !selector.Matches(labels.Set(expectedLabels)) {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("spec").Child("selector"), obj.Spec.Selector, "`selector` not auto-generated"))
                }
        }

        return allErrs
}

// ValidateJob validates a Job and returns an ErrorList with any errors.
func ValidateJob(job *batch.Job, opts JobValidationOptions) field.ErrorList {
        // Jobs and rcs have the same name validation
        allErrs := apivalidation.ValidateObjectMeta(&job.ObjectMeta, true, apivalidation.ValidateReplicationControllerName, field.NewPath("metadata"))
        allErrs = append(allErrs, validateGeneratedSelector(job, opts.RequirePrefixedLabels)...)
        allErrs = append(allErrs, ValidateJobSpec(&job.Spec, field.NewPath("spec"), opts.PodValidationOptions)...)
        if job.Spec.CompletionMode != nil && *job.Spec.CompletionMode == batch.IndexedCompletion && job.Spec.Completions != nil && *job.Spec.Completions > 0 {
                // For indexed job, the job controller appends a suffix (`-$INDEX`)
                // to the pod hostname when indexed job create pods.
                // The index could be maximum `.spec.completions-1`
                // If we don't validate this here, the indexed job will fail to create pods later.
                maximumPodHostname := fmt.Sprintf("%s-%d", job.ObjectMeta.Name, *job.Spec.Completions-1)
                if errs := apimachineryvalidation.IsDNS1123Label(maximumPodHostname); len(errs) > 0 {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("metadata").Child("name"), job.ObjectMeta.Name, fmt.Sprintf("will not able to create pod with invalid DNS label: %s", maximumPodHostname)))
                }
        }
        return allErrs
}

// ValidateJobSpec validates a JobSpec and returns an ErrorList with any errors.
func ValidateJobSpec(spec *batch.JobSpec, fldPath *field.Path, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := validateJobSpec(spec, fldPath, opts)
        if spec.Selector == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("selector"), ""))
        } else {
                labelSelectorValidationOpts := unversionedvalidation.LabelSelectorValidationOptions{
                        AllowInvalidLabelValueInSelector: opts.AllowInvalidLabelValueInSelector,
                }
                allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, labelSelectorValidationOpts, fldPath.Child("selector"))...)
        }

        // Whether manually or automatically generated, the selector of the job must match the pods it will produce.
        if selector, err := metav1.LabelSelectorAsSelector(spec.Selector); err == nil {
                labels := labels.Set(spec.Template.Labels)
                if !selector.Matches(labels) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("template", "metadata", "labels"), spec.Template.Labels, "`selector` does not match template `labels`"))
                }
        }
        return allErrs
}

func validateJobSpec(spec *batch.JobSpec, fldPath *field.Path, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if spec.Parallelism != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.Parallelism), fldPath.Child("parallelism"))...)
        }
        if spec.Completions != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.Completions), fldPath.Child("completions"))...)
        }
        if spec.ActiveDeadlineSeconds != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.ActiveDeadlineSeconds), fldPath.Child("activeDeadlineSeconds"))...)
        }
        if spec.BackoffLimit != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.BackoffLimit), fldPath.Child("backoffLimit"))...)
        }
        if spec.TTLSecondsAfterFinished != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.TTLSecondsAfterFinished), fldPath.Child("ttlSecondsAfterFinished"))...)
        }
        if spec.BackoffLimitPerIndex != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.BackoffLimitPerIndex), fldPath.Child("backoffLimitPerIndex"))...)
        }
        if spec.MaxFailedIndexes != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.MaxFailedIndexes), fldPath.Child("maxFailedIndexes"))...)
                if spec.BackoffLimitPerIndex == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("backoffLimitPerIndex"), fmt.Sprintf("when maxFailedIndexes is specified")))
                }
        }
        if spec.ManagedBy != nil {
                allErrs = append(allErrs, apimachineryvalidation.IsDomainPrefixedPath(fldPath.Child("managedBy"), *spec.ManagedBy)...)
                if len(*spec.ManagedBy) > maxManagedByLength {
                        allErrs = append(allErrs, field.TooLong(fldPath.Child("managedBy"), "" /*unused*/, maxManagedByLength))
                }
        }
        if spec.CompletionMode != nil {
                if *spec.CompletionMode != batch.NonIndexedCompletion && *spec.CompletionMode != batch.IndexedCompletion {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("completionMode"), spec.CompletionMode, []batch.CompletionMode{batch.NonIndexedCompletion, batch.IndexedCompletion}))
                }
                if *spec.CompletionMode == batch.IndexedCompletion {
                        if spec.Completions == nil {
                                allErrs = append(allErrs, field.Required(fldPath.Child("completions"), fmt.Sprintf("when completion mode is %s", batch.IndexedCompletion)))
                        }
                        if spec.Parallelism != nil && *spec.Parallelism > maxParallelismForIndexedJob {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("parallelism"), *spec.Parallelism, fmt.Sprintf("must be less than or equal to %d when completion mode is %s", maxParallelismForIndexedJob, batch.IndexedCompletion)))
                        }
                        if spec.Completions != nil && spec.MaxFailedIndexes != nil && *spec.MaxFailedIndexes > *spec.Completions {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("maxFailedIndexes"), *spec.MaxFailedIndexes, "must be less than or equal to completions"))
                        }
                        if spec.MaxFailedIndexes != nil && *spec.MaxFailedIndexes > maxFailedIndexesForIndexedJob {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("maxFailedIndexes"), *spec.MaxFailedIndexes, fmt.Sprintf("must be less than or equal to %d", maxFailedIndexesForIndexedJob)))
                        }
                        if spec.Completions != nil && *spec.Completions > completionsSoftLimit && spec.BackoffLimitPerIndex != nil {
                                if spec.MaxFailedIndexes == nil {
                                        allErrs = append(allErrs, field.Required(fldPath.Child("maxFailedIndexes"), fmt.Sprintf("must be specified when completions is above %d", completionsSoftLimit)))
                                }
                                if spec.Parallelism != nil && *spec.Parallelism > parallelismLimitForHighCompletions {
                                        allErrs = append(allErrs, field.Invalid(fldPath.Child("parallelism"), *spec.Parallelism, fmt.Sprintf("must be less than or equal to %d when completions are above %d and used with backoff limit per index", parallelismLimitForHighCompletions, completionsSoftLimit)))
                                }
                                if spec.MaxFailedIndexes != nil && *spec.MaxFailedIndexes > maxFailedIndexesLimitForHighCompletions {
                                        allErrs = append(allErrs, field.Invalid(fldPath.Child("maxFailedIndexes"), *spec.MaxFailedIndexes, fmt.Sprintf("must be less than or equal to %d when completions are above %d and used with backoff limit per index", maxFailedIndexesLimitForHighCompletions, completionsSoftLimit)))
                                }
                        }
                }
        }
        if spec.CompletionMode == nil || *spec.CompletionMode == batch.NonIndexedCompletion {
                if spec.BackoffLimitPerIndex != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("backoffLimitPerIndex"), *spec.BackoffLimitPerIndex, "requires indexed completion mode"))
                }
                if spec.MaxFailedIndexes != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("maxFailedIndexes"), *spec.MaxFailedIndexes, "requires indexed completion mode"))
                }
        }

        if spec.PodFailurePolicy != nil {
                allErrs = append(allErrs, validatePodFailurePolicy(spec, fldPath.Child("podFailurePolicy"))...)
        }
        if spec.SuccessPolicy != nil {
                if ptr.Deref(spec.CompletionMode, batch.NonIndexedCompletion) != batch.IndexedCompletion {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("successPolicy"), *spec.SuccessPolicy, "requires indexed completion mode"))
                } else {
                        allErrs = append(allErrs, validateSuccessPolicy(spec, fldPath.Child("successPolicy"))...)
                }
        }

        allErrs = append(allErrs, validatePodReplacementPolicy(spec, fldPath.Child("podReplacementPolicy"))...)

        allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpec(&spec.Template, fldPath.Child("template"), opts)...)

        // spec.Template.Spec.RestartPolicy can be defaulted as RestartPolicyAlways
        // by SetDefaults_PodSpec function when the user does not explicitly specify a value for it,
        // so we check both empty and RestartPolicyAlways cases here
        if spec.Template.Spec.RestartPolicy == api.RestartPolicyAlways || spec.Template.Spec.RestartPolicy == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("template", "spec", "restartPolicy"),
                        fmt.Sprintf("valid values: %q, %q", api.RestartPolicyOnFailure, api.RestartPolicyNever)))
        } else if spec.Template.Spec.RestartPolicy != api.RestartPolicyOnFailure && spec.Template.Spec.RestartPolicy != api.RestartPolicyNever {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("template", "spec", "restartPolicy"),
                        spec.Template.Spec.RestartPolicy, []api.RestartPolicy{api.RestartPolicyOnFailure, api.RestartPolicyNever}))
        } else if spec.PodFailurePolicy != nil && spec.Template.Spec.RestartPolicy != api.RestartPolicyNever {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("template", "spec", "restartPolicy"),
                        spec.Template.Spec.RestartPolicy, fmt.Sprintf("only %q is supported when podFailurePolicy is specified", api.RestartPolicyNever)))
        }
        return allErrs
}

func validatePodFailurePolicy(spec *batch.JobSpec, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        rulesPath := fldPath.Child("rules")
        if len(spec.PodFailurePolicy.Rules) > maxPodFailurePolicyRules {
                allErrs = append(allErrs, field.TooMany(rulesPath, len(spec.PodFailurePolicy.Rules), maxPodFailurePolicyRules))
        }
        containerNames := sets.NewString()
        for _, containerSpec := range spec.Template.Spec.Containers {
                containerNames.Insert(containerSpec.Name)
        }
        for _, containerSpec := range spec.Template.Spec.InitContainers {
                containerNames.Insert(containerSpec.Name)
        }
        for i, rule := range spec.PodFailurePolicy.Rules {
                allErrs = append(allErrs, validatePodFailurePolicyRule(spec, &rule, rulesPath.Index(i), containerNames)...)
        }
        return allErrs
}

func validatePodReplacementPolicy(spec *batch.JobSpec, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        if spec.PodReplacementPolicy != nil {
                // If PodFailurePolicy is specified then we only allow Failed.
                if spec.PodFailurePolicy != nil {
                        if *spec.PodReplacementPolicy != batch.Failed {
                                allErrs = append(allErrs, field.NotSupported(fldPath, *spec.PodReplacementPolicy, []batch.PodReplacementPolicy{batch.Failed}))
                        }
                        // If PodFailurePolicy not specified we allow values in supportedPodReplacementPolicy.
                } else if !supportedPodReplacementPolicy.Has(*spec.PodReplacementPolicy) {
                        allErrs = append(allErrs, field.NotSupported(fldPath, *spec.PodReplacementPolicy, sets.List(supportedPodReplacementPolicy)))
                }
        }
        return allErrs
}

func validatePodFailurePolicyRule(spec *batch.JobSpec, rule *batch.PodFailurePolicyRule, rulePath *field.Path, containerNames sets.String) field.ErrorList {
        var allErrs field.ErrorList
        actionPath := rulePath.Child("action")
        if rule.Action == "" {
                allErrs = append(allErrs, field.Required(actionPath, fmt.Sprintf("valid values: %q", sets.List(supportedPodFailurePolicyActions))))
        } else if rule.Action == batch.PodFailurePolicyActionFailIndex {
                if spec.BackoffLimitPerIndex == nil {
                        allErrs = append(allErrs, field.Invalid(actionPath, rule.Action, "requires the backoffLimitPerIndex to be set"))
                }
        } else if !supportedPodFailurePolicyActions.Has(rule.Action) {
                allErrs = append(allErrs, field.NotSupported(actionPath, rule.Action, sets.List(supportedPodFailurePolicyActions)))
        }
        if rule.OnExitCodes != nil {
                allErrs = append(allErrs, validatePodFailurePolicyRuleOnExitCodes(rule.OnExitCodes, rulePath.Child("onExitCodes"), containerNames)...)
        }
        if len(rule.OnPodConditions) > 0 {
                allErrs = append(allErrs, validatePodFailurePolicyRuleOnPodConditions(rule.OnPodConditions, rulePath.Child("onPodConditions"))...)
        }
        if rule.OnExitCodes != nil && len(rule.OnPodConditions) > 0 {
                allErrs = append(allErrs, field.Invalid(rulePath, field.OmitValueType{}, "specifying both OnExitCodes and OnPodConditions is not supported"))
        }
        if rule.OnExitCodes == nil && len(rule.OnPodConditions) == 0 {
                allErrs = append(allErrs, field.Invalid(rulePath, field.OmitValueType{}, "specifying one of OnExitCodes and OnPodConditions is required"))
        }
        return allErrs
}

func validatePodFailurePolicyRuleOnPodConditions(onPodConditions []batch.PodFailurePolicyOnPodConditionsPattern, onPodConditionsPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        if len(onPodConditions) > maxPodFailurePolicyOnPodConditionsPatterns {
                allErrs = append(allErrs, field.TooMany(onPodConditionsPath, len(onPodConditions), maxPodFailurePolicyOnPodConditionsPatterns))
        }
        for j, pattern := range onPodConditions {
                patternPath := onPodConditionsPath.Index(j)
                statusPath := patternPath.Child("status")
                allErrs = append(allErrs, apivalidation.ValidateQualifiedName(string(pattern.Type), patternPath.Child("type"))...)
                if pattern.Status == "" {
                        allErrs = append(allErrs, field.Required(statusPath, fmt.Sprintf("valid values: %q", sets.List(supportedPodFailurePolicyOnPodConditionsStatus))))
                } else if !supportedPodFailurePolicyOnPodConditionsStatus.Has(pattern.Status) {
                        allErrs = append(allErrs, field.NotSupported(statusPath, pattern.Status, sets.List(supportedPodFailurePolicyOnPodConditionsStatus)))
                }
        }
        return allErrs
}

func validatePodFailurePolicyRuleOnExitCodes(onExitCode *batch.PodFailurePolicyOnExitCodesRequirement, onExitCodesPath *field.Path, containerNames sets.String) field.ErrorList {
        var allErrs field.ErrorList
        operatorPath := onExitCodesPath.Child("operator")
        if onExitCode.Operator == "" {
                allErrs = append(allErrs, field.Required(operatorPath, fmt.Sprintf("valid values: %q", sets.List(supportedPodFailurePolicyOnExitCodesOperator))))
        } else if !supportedPodFailurePolicyOnExitCodesOperator.Has(onExitCode.Operator) {
                allErrs = append(allErrs, field.NotSupported(operatorPath, onExitCode.Operator, sets.List(supportedPodFailurePolicyOnExitCodesOperator)))
        }
        if onExitCode.ContainerName != nil && !containerNames.Has(*onExitCode.ContainerName) {
                allErrs = append(allErrs, field.Invalid(onExitCodesPath.Child("containerName"), *onExitCode.ContainerName, "must be one of the container or initContainer names in the pod template"))
        }
        valuesPath := onExitCodesPath.Child("values")
        if len(onExitCode.Values) == 0 {
                allErrs = append(allErrs, field.Invalid(valuesPath, onExitCode.Values, "at least one value is required"))
        } else if len(onExitCode.Values) > maxPodFailurePolicyOnExitCodesValues {
                allErrs = append(allErrs, field.TooMany(valuesPath, len(onExitCode.Values), maxPodFailurePolicyOnExitCodesValues))
        }
        isOrdered := true
        uniqueValues := sets.NewInt32()
        for j, exitCodeValue := range onExitCode.Values {
                valuePath := valuesPath.Index(j)
                if onExitCode.Operator == batch.PodFailurePolicyOnExitCodesOpIn && exitCodeValue == 0 {
                        allErrs = append(allErrs, field.Invalid(valuePath, exitCodeValue, "must not be 0 for the In operator"))
                }
                if uniqueValues.Has(exitCodeValue) {
                        allErrs = append(allErrs, field.Duplicate(valuePath, exitCodeValue))
                } else {
                        uniqueValues.Insert(exitCodeValue)
                }
                if j > 0 && onExitCode.Values[j-1] > exitCodeValue {
                        isOrdered = false
                }
        }
        if !isOrdered {
                allErrs = append(allErrs, field.Invalid(valuesPath, onExitCode.Values, "must be ordered"))
        }

        return allErrs
}

func validateSuccessPolicy(spec *batch.JobSpec, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        rulesPath := fldPath.Child("rules")
        if len(spec.SuccessPolicy.Rules) == 0 {
                allErrs = append(allErrs, field.Required(rulesPath, "at least one rules must be specified when the successPolicy is specified"))
        }
        if len(spec.SuccessPolicy.Rules) > maxSuccessPolicyRule {
                allErrs = append(allErrs, field.TooMany(rulesPath, len(spec.SuccessPolicy.Rules), maxSuccessPolicyRule))
        }
        for i, rule := range spec.SuccessPolicy.Rules {
                allErrs = append(allErrs, validateSuccessPolicyRule(spec, &rule, rulesPath.Index(i))...)
        }
        return allErrs
}

func validateSuccessPolicyRule(spec *batch.JobSpec, rule *batch.SuccessPolicyRule, rulePath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        if rule.SucceededCount == nil && rule.SucceededIndexes == nil {
                allErrs = append(allErrs, field.Required(rulePath, "at least one of succeededCount or succeededIndexes must be specified"))
        }
        var totalIndexes int32
        if rule.SucceededIndexes != nil {
                succeededIndexes := rulePath.Child("succeededIndexes")
                if len(*rule.SucceededIndexes) > maxJobSuccessPolicySucceededIndexesLimit {
                        allErrs = append(allErrs, field.TooLong(succeededIndexes, "" /*unused*/, maxJobSuccessPolicySucceededIndexesLimit))
                }
                var err error
                if totalIndexes, err = validateIndexesFormat(*rule.SucceededIndexes, *spec.Completions); err != nil {
                        allErrs = append(allErrs, field.Invalid(succeededIndexes, *rule.SucceededIndexes, fmt.Sprintf("error parsing succeededIndexes: %s", err.Error())))
                }
        }
        if rule.SucceededCount != nil {
                succeededCountPath := rulePath.Child("succeededCount")
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*rule.SucceededCount), succeededCountPath)...)
                if *rule.SucceededCount > *spec.Completions {
                        allErrs = append(allErrs, field.Invalid(succeededCountPath, *rule.SucceededCount, fmt.Sprintf("must be less than or equal to %d (the number of specified completions)", *spec.Completions)))
                }
                if rule.SucceededIndexes != nil && *rule.SucceededCount > totalIndexes {
                        allErrs = append(allErrs, field.Invalid(succeededCountPath, *rule.SucceededCount, fmt.Sprintf("must be less than or equal to %d (the number of indexes in the specified succeededIndexes field)", totalIndexes)))
                }
        }
        return allErrs
}

// validateJobStatus validates a JobStatus and returns an ErrorList with any errors.
func validateJobStatus(job *batch.Job, fldPath *field.Path, opts JobStatusValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        status := job.Status
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.Active), fldPath.Child("active"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.Succeeded), fldPath.Child("succeeded"))...)
        allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(status.Failed), fldPath.Child("failed"))...)
        if status.Ready != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*status.Ready), fldPath.Child("ready"))...)
        }
        if status.Terminating != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*status.Terminating), fldPath.Child("terminating"))...)
        }
        if status.UncountedTerminatedPods != nil {
                path := fldPath.Child("uncountedTerminatedPods")
                seen := sets.New[types.UID]()
                for i, k := range status.UncountedTerminatedPods.Succeeded {
                        p := path.Child("succeeded").Index(i)
                        if k == "" {
                                allErrs = append(allErrs, field.Invalid(p, k, "must not be empty"))
                        } else if seen.Has(k) {
                                allErrs = append(allErrs, field.Duplicate(p, k))
                        } else {
                                seen.Insert(k)
                        }
                }
                for i, k := range status.UncountedTerminatedPods.Failed {
                        p := path.Child("failed").Index(i)
                        if k == "" {
                                allErrs = append(allErrs, field.Invalid(p, k, "must not be empty"))
                        } else if seen.Has(k) {
                                allErrs = append(allErrs, field.Duplicate(p, k))
                        } else {
                                seen.Insert(k)
                        }
                }
        }
        if opts.RejectCompleteJobWithFailedCondition {
                if IsJobComplete(job) && IsJobFailed(job) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set Complete=True and Failed=true conditions"))
                }
        }
        if opts.RejectCompleteJobWithFailureTargetCondition {
                if IsJobComplete(job) && IsConditionTrue(status.Conditions, batch.JobFailureTarget) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set Complete=True and FailureTarget=true conditions"))
                }
        }
        if opts.RejectNotCompleteJobWithCompletionTime {
                if status.CompletionTime != nil && !IsJobComplete(job) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("completionTime"), status.CompletionTime, "cannot set completionTime when there is no Complete=True condition"))
                }
        }
        if opts.RejectCompleteJobWithoutCompletionTime {
                if status.CompletionTime == nil && IsJobComplete(job) {
                        allErrs = append(allErrs, field.Required(fldPath.Child("completionTime"), "completionTime is required for Complete jobs"))
                }
        }
        if opts.RejectCompletionTimeBeforeStartTime {
                if status.StartTime != nil && status.CompletionTime != nil && status.CompletionTime.Before(status.StartTime) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("completionTime"), status.CompletionTime, "must be equal to or after `startTime`"))
                }
        }
        if opts.RejectFailedJobWithoutFailureTarget {
                if IsJobFailed(job) && !isJobFailureTarget(job) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set Failed=True condition without the FailureTarget=true condition"))
                }
        }
        if opts.RejectCompleteJobWithoutSuccessCriteriaMet {
                if IsJobComplete(job) && !isJobSuccessCriteriaMet(job) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set Complete=True condition without the SuccessCriteriaMet=true condition"))
                }
        }
        isJobFinished := IsJobFinished(job)
        if opts.RejectFinishedJobWithActivePods {
                if status.Active > 0 && isJobFinished {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("active"), status.Active, "active>0 is invalid for finished job"))
                }
        }
        if opts.RejectFinishedJobWithoutStartTime {
                if status.StartTime == nil && isJobFinished {
                        allErrs = append(allErrs, field.Required(fldPath.Child("startTime"), "startTime is required for finished job"))
                }
        }
        if opts.RejectFinishedJobWithUncountedTerminatedPods {
                if isJobFinished && status.UncountedTerminatedPods != nil && len(status.UncountedTerminatedPods.Failed)+len(status.UncountedTerminatedPods.Succeeded) > 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("uncountedTerminatedPods"), status.UncountedTerminatedPods, "must be empty for finished job"))
                }
        }
        if opts.RejectInvalidCompletedIndexes {
                if job.Spec.Completions != nil {
                        if _, err := validateIndexesFormat(status.CompletedIndexes, int32(*job.Spec.Completions)); err != nil {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("completedIndexes"), status.CompletedIndexes, fmt.Sprintf("error parsing completedIndexes: %s", err.Error())))
                        }
                }
        }
        if opts.RejectInvalidFailedIndexes {
                if job.Spec.Completions != nil && job.Spec.BackoffLimitPerIndex != nil && status.FailedIndexes != nil {
                        if _, err := validateIndexesFormat(*status.FailedIndexes, int32(*job.Spec.Completions)); err != nil {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("failedIndexes"), status.FailedIndexes, fmt.Sprintf("error parsing failedIndexes: %s", err.Error())))
                        }
                }
        }
        isIndexed := ptr.Deref(job.Spec.CompletionMode, batch.NonIndexedCompletion) == batch.IndexedCompletion
        if opts.RejectCompletedIndexesForNonIndexedJob {
                if len(status.CompletedIndexes) != 0 && !isIndexed {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("completedIndexes"), status.CompletedIndexes, "cannot set non-empty completedIndexes when non-indexed completion mode"))
                }
        }
        if opts.RejectFailedIndexesForNoBackoffLimitPerIndex {
                // Note that this check also verifies that FailedIndexes are not used for
                // regular (non-indexed) jobs, because regular jobs have backoffLimitPerIndex = nil.
                if job.Spec.BackoffLimitPerIndex == nil && status.FailedIndexes != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("failedIndexes"), *status.FailedIndexes, "cannot set non-null failedIndexes when backoffLimitPerIndex is null"))
                }
        }
        if opts.RejectFailedIndexesOverlappingCompleted {
                if job.Spec.Completions != nil && status.FailedIndexes != nil {
                        if err := validateFailedIndexesNotOverlapCompleted(status.CompletedIndexes, *status.FailedIndexes, int32(*job.Spec.Completions)); err != nil {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("failedIndexes"), *status.FailedIndexes, err.Error()))
                        }
                }
        }
        if opts.RejectFinishedJobWithTerminatingPods {
                if status.Terminating != nil && *status.Terminating > 0 && isJobFinished {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("terminating"), status.Terminating, "terminating>0 is invalid for finished job"))
                }
        }
        if opts.RejectMoreReadyThanActivePods {
                if status.Ready != nil && *status.Ready > status.Active {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("ready"), *status.Ready, "cannot set more ready pods than active"))
                }
        }
        if !opts.AllowForSuccessCriteriaMetInExtendedScope && ptr.Deref(job.Spec.CompletionMode, batch.NonIndexedCompletion) != batch.IndexedCompletion && isJobSuccessCriteriaMet(job) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set SuccessCriteriaMet to NonIndexed Job"))
        }
        if isJobSuccessCriteriaMet(job) && IsJobFailed(job) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set SuccessCriteriaMet=True and Failed=true conditions"))
        }
        if isJobSuccessCriteriaMet(job) && isJobFailureTarget(job) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set SuccessCriteriaMet=True and FailureTarget=true conditions"))
        }
        if !opts.AllowForSuccessCriteriaMetInExtendedScope && job.Spec.SuccessPolicy == nil && isJobSuccessCriteriaMet(job) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set SuccessCriteriaMet=True for Job without SuccessPolicy"))
        }
        if job.Spec.SuccessPolicy != nil && !isJobSuccessCriteriaMet(job) && IsJobComplete(job) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("conditions"), field.OmitValueType{}, "cannot set Complete=True for Job with SuccessPolicy unless SuccessCriteriaMet=True"))
        }
        return allErrs
}

// ValidateJobUpdate validates an update to a Job and returns an ErrorList with any errors.
func ValidateJobUpdate(job, oldJob *batch.Job, opts JobValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&job.ObjectMeta, &oldJob.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateJobSpecUpdate(job.Spec, oldJob.Spec, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateJobUpdateStatus validates an update to the status of a Job and returns an ErrorList with any errors.
func ValidateJobUpdateStatus(job, oldJob *batch.Job, opts JobStatusValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&job.ObjectMeta, &oldJob.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateJobStatusUpdate(job, oldJob, opts)...)
        return allErrs
}

// ValidateJobSpecUpdate validates an update to a JobSpec and returns an ErrorList with any errors.
func ValidateJobSpecUpdate(spec, oldSpec batch.JobSpec, fldPath *field.Path, opts JobValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateJobSpec(&spec, fldPath, opts.PodValidationOptions)...)
        allErrs = append(allErrs, validateCompletions(spec, oldSpec, fldPath.Child("completions"), opts)...)
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(spec.Selector, oldSpec.Selector, fldPath.Child("selector"))...)
        allErrs = append(allErrs, validatePodTemplateUpdate(spec, oldSpec, fldPath, opts)...)
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(spec.CompletionMode, oldSpec.CompletionMode, fldPath.Child("completionMode"))...)
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(spec.PodFailurePolicy, oldSpec.PodFailurePolicy, fldPath.Child("podFailurePolicy"))...)
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(spec.BackoffLimitPerIndex, oldSpec.BackoffLimitPerIndex, fldPath.Child("backoffLimitPerIndex"))...)
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(spec.ManagedBy, oldSpec.ManagedBy, fldPath.Child("managedBy"))...)
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(spec.SuccessPolicy, oldSpec.SuccessPolicy, fldPath.Child("successPolicy"))...)
        return allErrs
}

func validatePodTemplateUpdate(spec, oldSpec batch.JobSpec, fldPath *field.Path, opts JobValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        template := &spec.Template
        oldTemplate := &oldSpec.Template
        if opts.AllowMutableSchedulingDirectives {
                oldTemplate = oldSpec.Template.DeepCopy() // +k8s:verify-mutation:reason=clone
                switch {
                case template.Spec.Affinity == nil && oldTemplate.Spec.Affinity != nil:
                        // allow the Affinity field to be cleared if the old template had no affinity directives other than NodeAffinity
                        oldTemplate.Spec.Affinity.NodeAffinity = nil // +k8s:verify-mutation:reason=clone
                        if (*oldTemplate.Spec.Affinity) == (api.Affinity{}) {
                                oldTemplate.Spec.Affinity = nil // +k8s:verify-mutation:reason=clone
                        }
                case template.Spec.Affinity != nil && oldTemplate.Spec.Affinity == nil:
                        // allow the NodeAffinity field to skip immutability checking
                        oldTemplate.Spec.Affinity = &api.Affinity{NodeAffinity: template.Spec.Affinity.NodeAffinity} // +k8s:verify-mutation:reason=clone
                case template.Spec.Affinity != nil && oldTemplate.Spec.Affinity != nil:
                        // allow the NodeAffinity field to skip immutability checking
                        oldTemplate.Spec.Affinity.NodeAffinity = template.Spec.Affinity.NodeAffinity // +k8s:verify-mutation:reason=clone
                }
                oldTemplate.Spec.NodeSelector = template.Spec.NodeSelector       // +k8s:verify-mutation:reason=clone
                oldTemplate.Spec.Tolerations = template.Spec.Tolerations         // +k8s:verify-mutation:reason=clone
                oldTemplate.Annotations = template.Annotations                   // +k8s:verify-mutation:reason=clone
                oldTemplate.Labels = template.Labels                             // +k8s:verify-mutation:reason=clone
                oldTemplate.Spec.SchedulingGates = template.Spec.SchedulingGates // +k8s:verify-mutation:reason=clone
        }
        allErrs = append(allErrs, apivalidation.ValidateImmutableField(template, oldTemplate, fldPath.Child("template"))...)
        return allErrs
}

// ValidateJobStatusUpdate validates an update to a JobStatus and returns an ErrorList with any errors.
func ValidateJobStatusUpdate(job, oldJob *batch.Job, opts JobStatusValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        statusFld := field.NewPath("status")
        allErrs = append(allErrs, validateJobStatus(job, statusFld, opts)...)

        if opts.RejectDisablingTerminalCondition {
                for _, cType := range []batch.JobConditionType{batch.JobFailed, batch.JobComplete, batch.JobFailureTarget} {
                        if IsConditionTrue(oldJob.Status.Conditions, cType) && !IsConditionTrue(job.Status.Conditions, cType) {
                                allErrs = append(allErrs, field.Invalid(statusFld.Child("conditions"), field.OmitValueType{}, fmt.Sprintf("cannot disable the terminal %s=True condition", string(cType))))
                        }
                }
        }
        if opts.RejectDecreasingFailedCounter {
                if job.Status.Failed < oldJob.Status.Failed {
                        allErrs = append(allErrs, field.Invalid(statusFld.Child("failed"), job.Status.Failed, "cannot decrease the failed counter"))
                }
        }
        if opts.RejectDecreasingSucceededCounter {
                if job.Status.Succeeded < oldJob.Status.Succeeded {
                        allErrs = append(allErrs, field.Invalid(statusFld.Child("succeeded"), job.Status.Succeeded, "cannot decrease the succeeded counter"))
                }
        }
        if opts.RejectMutatingCompletionTime {
                // Note that we check the condition only when `job.Status.CompletionTime != nil`, this is because
                // we don't want to block transitions to completionTime = nil when the job is not finished yet.
                // Setting completionTime = nil for finished jobs is prevented in RejectCompleteJobWithoutCompletionTime.
                if job.Status.CompletionTime != nil && oldJob.Status.CompletionTime != nil && !ptr.Equal(job.Status.CompletionTime, oldJob.Status.CompletionTime) {
                        allErrs = append(allErrs, field.Invalid(statusFld.Child("completionTime"), job.Status.CompletionTime, "field is immutable"))
                }
        }
        if opts.RejectStartTimeUpdateForUnsuspendedJob {
                // Note that we check `oldJob.Status.StartTime != nil` to allow transitioning from
                // startTime = nil to startTime != nil for unsuspended jobs, which is a desired transition.
                if oldJob.Status.StartTime != nil && !ptr.Equal(oldJob.Status.StartTime, job.Status.StartTime) && !ptr.Deref(job.Spec.Suspend, false) {
                        allErrs = append(allErrs, field.Required(statusFld.Child("startTime"), "startTime cannot be removed for unsuspended job"))
                }
        }
        if isJobSuccessCriteriaMet(oldJob) && !isJobSuccessCriteriaMet(job) {
                allErrs = append(allErrs, field.Invalid(statusFld.Child("conditions"), field.OmitValueType{}, "cannot disable the SuccessCriteriaMet=True condition"))
        }
        if IsJobComplete(oldJob) && !isJobSuccessCriteriaMet(oldJob) && isJobSuccessCriteriaMet(job) {
                allErrs = append(allErrs, field.Invalid(statusFld.Child("conditions"), field.OmitValueType{}, "cannot set SuccessCriteriaMet=True for Job already has Complete=true conditions"))
        }
        return allErrs
}

// ValidateCronJobCreate validates a CronJob on creation and returns an ErrorList with any errors.
func ValidateCronJobCreate(cronJob *batch.CronJob, opts apivalidation.PodValidationOptions) field.ErrorList {
        // CronJobs and rcs have the same name validation
        allErrs := apivalidation.ValidateObjectMeta(&cronJob.ObjectMeta, true, apivalidation.ValidateReplicationControllerName, field.NewPath("metadata"))
        allErrs = append(allErrs, validateCronJobSpec(&cronJob.Spec, nil, field.NewPath("spec"), opts)...)
        if len(cronJob.ObjectMeta.Name) > apimachineryvalidation.DNS1035LabelMaxLength-11 {
                // The cronjob controller appends a 11-character suffix to the cronjob (`-$TIMESTAMP`) when
                // creating a job. The job name length limit is 63 characters.
                // Therefore cronjob names must have length <= 63-11=52. If we don't validate this here,
                // then job creation will fail later.
                allErrs = append(allErrs, field.Invalid(field.NewPath("metadata").Child("name"), cronJob.ObjectMeta.Name, "must be no more than 52 characters"))
        }
        return allErrs
}

// ValidateCronJobUpdate validates an update to a CronJob and returns an ErrorList with any errors.
func ValidateCronJobUpdate(job, oldJob *batch.CronJob, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := apivalidation.ValidateObjectMetaUpdate(&job.ObjectMeta, &oldJob.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, validateCronJobSpec(&job.Spec, &oldJob.Spec, field.NewPath("spec"), opts)...)

        // skip the 52-character name validation limit on update validation
        // to allow old cronjobs with names > 52 chars to be updated/deleted
        return allErrs
}

// validateCronJobSpec validates a CronJobSpec and returns an ErrorList with any errors.
func validateCronJobSpec(spec, oldSpec *batch.CronJobSpec, fldPath *field.Path, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(spec.Schedule) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("schedule"), ""))
        } else {
                allowTZInSchedule := false
                if oldSpec != nil {
                        allowTZInSchedule = strings.Contains(oldSpec.Schedule, "TZ")
                }
                allErrs = append(allErrs, validateScheduleFormat(spec.Schedule, allowTZInSchedule, spec.TimeZone, fldPath.Child("schedule"))...)
        }

        if spec.StartingDeadlineSeconds != nil {
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.StartingDeadlineSeconds), fldPath.Child("startingDeadlineSeconds"))...)
        }

        if oldSpec == nil || !ptr.Equal(oldSpec.TimeZone, spec.TimeZone) {
                allErrs = append(allErrs, validateTimeZone(spec.TimeZone, fldPath.Child("timeZone"))...)
        }

        allErrs = append(allErrs, validateConcurrencyPolicy(&spec.ConcurrencyPolicy, fldPath.Child("concurrencyPolicy"))...)
        allErrs = append(allErrs, ValidateJobTemplateSpec(&spec.JobTemplate, fldPath.Child("jobTemplate"), opts)...)

        if spec.SuccessfulJobsHistoryLimit != nil {
                // zero is a valid SuccessfulJobsHistoryLimit
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.SuccessfulJobsHistoryLimit), fldPath.Child("successfulJobsHistoryLimit"))...)
        }
        if spec.FailedJobsHistoryLimit != nil {
                // zero is a valid SuccessfulJobsHistoryLimit
                allErrs = append(allErrs, apivalidation.ValidateNonnegativeField(int64(*spec.FailedJobsHistoryLimit), fldPath.Child("failedJobsHistoryLimit"))...)
        }

        return allErrs
}

func validateConcurrencyPolicy(concurrencyPolicy *batch.ConcurrencyPolicy, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        switch *concurrencyPolicy {
        case batch.AllowConcurrent, batch.ForbidConcurrent, batch.ReplaceConcurrent:
                break
        case "":
                allErrs = append(allErrs, field.Required(fldPath, ""))
        default:
                validValues := []batch.ConcurrencyPolicy{batch.AllowConcurrent, batch.ForbidConcurrent, batch.ReplaceConcurrent}
                allErrs = append(allErrs, field.NotSupported(fldPath, *concurrencyPolicy, validValues))
        }

        return allErrs
}

func validateScheduleFormat(schedule string, allowTZInSchedule bool, timeZone *string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if _, err := cron.ParseStandard(schedule); err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath, schedule, err.Error()))
        }
        switch {
        case allowTZInSchedule && strings.Contains(schedule, "TZ") && timeZone != nil:
                allErrs = append(allErrs, field.Invalid(fldPath, schedule, "cannot use both timeZone field and TZ or CRON_TZ in schedule"))
        case !allowTZInSchedule && strings.Contains(schedule, "TZ"):
                allErrs = append(allErrs, field.Invalid(fldPath, schedule, "cannot use TZ or CRON_TZ in schedule, use timeZone field instead"))
        }

        return allErrs
}

// https://data.iana.org/time-zones/theory.html#naming
// * A name must not be empty, or contain '//', or start or end with '/'.
// * Do not use the file name components '.' and '..'.
// * Within a file name component, use only ASCII letters, '.', '-' and '_'.
// * Do not use digits, as that might create an ambiguity with POSIX TZ strings.
// * A file name component must not exceed 14 characters or start with '-'
//
// 0-9 and + characters are tolerated to accommodate legacy compatibility names
var validTimeZoneCharacters = regexp.MustCompile(`^[A-Za-z\.\-_0-9+]{1,14}$`)

func validateTimeZone(timeZone *string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if timeZone == nil {
                return allErrs
        }

        if len(*timeZone) == 0 {
                allErrs = append(allErrs, field.Invalid(fldPath, timeZone, "timeZone must be nil or non-empty string"))
                return allErrs
        }

        for _, part := range strings.Split(*timeZone, "/") {
                if part == "." || part == ".." || strings.HasPrefix(part, "-") || !validTimeZoneCharacters.MatchString(part) {
                        allErrs = append(allErrs, field.Invalid(fldPath, timeZone, fmt.Sprintf("unknown time zone %s", *timeZone)))
                        return allErrs
                }
        }

        if strings.EqualFold(*timeZone, "Local") {
                allErrs = append(allErrs, field.Invalid(fldPath, timeZone, "timeZone must be an explicit time zone as defined in https://www.iana.org/time-zones"))
        }

        if _, err := time.LoadLocation(*timeZone); err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath, timeZone, err.Error()))
        }

        return allErrs
}

// ValidateJobTemplateSpec validates a JobTemplateSpec and returns an ErrorList with any errors.
func ValidateJobTemplateSpec(spec *batch.JobTemplateSpec, fldPath *field.Path, opts apivalidation.PodValidationOptions) field.ErrorList {
        allErrs := validateJobSpec(&spec.Spec, fldPath.Child("spec"), opts)

        // jobtemplate will always have the selector automatically generated
        if spec.Spec.Selector != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("spec", "selector"), spec.Spec.Selector, "`selector` will be auto-generated"))
        }
        if spec.Spec.ManualSelector != nil && *spec.Spec.ManualSelector {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("spec", "manualSelector"), spec.Spec.ManualSelector, []string{"nil", "false"}))
        }
        return allErrs
}

func validateCompletions(spec, oldSpec batch.JobSpec, fldPath *field.Path, opts JobValidationOptions) field.ErrorList {
        // Completions is immutable for non-indexed jobs, but mutable for Indexed Jobs.
        isIndexedJob := spec.CompletionMode != nil && *spec.CompletionMode == batch.IndexedCompletion
        if !isIndexedJob {
                return apivalidation.ValidateImmutableField(spec.Completions, oldSpec.Completions, fldPath)
        }

        var allErrs field.ErrorList
        if apiequality.Semantic.DeepEqual(spec.Completions, oldSpec.Completions) {
                return allErrs
        }
        // Indexed Jobs cannot set completions to nil. The nil check
        // is already performed in validateJobSpec, no need to add another error.
        if spec.Completions == nil {
                return allErrs
        }

        if *spec.Completions != *spec.Parallelism {
                allErrs = append(allErrs, field.Invalid(fldPath, spec.Completions, fmt.Sprintf("can only be modified in tandem with %s", fldPath.Root().Child("parallelism").String())))
        }
        return allErrs
}

func IsJobFinished(job *batch.Job) bool {
        for _, c := range job.Status.Conditions {
                if (c.Type == batch.JobComplete || c.Type == batch.JobFailed) && c.Status == api.ConditionTrue {
                        return true
                }
        }
        return false
}

func IsJobComplete(job *batch.Job) bool {
        return IsConditionTrue(job.Status.Conditions, batch.JobComplete)
}

func IsJobFailed(job *batch.Job) bool {
        return IsConditionTrue(job.Status.Conditions, batch.JobFailed)
}

func isJobSuccessCriteriaMet(job *batch.Job) bool {
        return IsConditionTrue(job.Status.Conditions, batch.JobSuccessCriteriaMet)
}

func isJobFailureTarget(job *batch.Job) bool {
        return IsConditionTrue(job.Status.Conditions, batch.JobFailureTarget)
}

func IsConditionTrue(list []batch.JobCondition, cType batch.JobConditionType) bool {
        for _, c := range list {
                if c.Type == cType && c.Status == api.ConditionTrue {
                        return true
                }
        }
        return false
}

func validateFailedIndexesNotOverlapCompleted(completedIndexesStr string, failedIndexesStr string, completions int32) error {
        if len(completedIndexesStr) == 0 || len(failedIndexesStr) == 0 {
                return nil
        }
        completedIndexesIntervals := strings.Split(completedIndexesStr, ",")
        failedIndexesIntervals := strings.Split(failedIndexesStr, ",")
        var completedPos, failedPos int
        cX, cY, cErr := parseIndexInterval(completedIndexesIntervals[completedPos], completions)
        fX, fY, fErr := parseIndexInterval(failedIndexesIntervals[failedPos], completions)
        for completedPos < len(completedIndexesIntervals) && failedPos < len(failedIndexesIntervals) {
                if cErr != nil {
                        // Failure to parse "completed" interval. We go to the next interval,
                        // the error will be reported to the user when validating the format.
                        completedPos++
                        if completedPos < len(completedIndexesIntervals) {
                                cX, cY, cErr = parseIndexInterval(completedIndexesIntervals[completedPos], completions)
                        }
                } else if fErr != nil {
                        // Failure to parse "failed" interval. We go to the next interval,
                        // the error will be reported to the user when validating the format.
                        failedPos++
                        if failedPos < len(failedIndexesIntervals) {
                                fX, fY, fErr = parseIndexInterval(failedIndexesIntervals[failedPos], completions)
                        }
                } else {
                        // We have one failed and one completed interval parsed.
                        if cX <= fY && fX <= cY {
                                return fmt.Errorf("failedIndexes and completedIndexes overlap at index: %d", max(cX, fX))
                        }
                        // No overlap, let's move to the next one.
                        if cX <= fX {
                                completedPos++
                                if completedPos < len(completedIndexesIntervals) {
                                        cX, cY, cErr = parseIndexInterval(completedIndexesIntervals[completedPos], completions)
                                }
                        } else {
                                failedPos++
                                if failedPos < len(failedIndexesIntervals) {
                                        fX, fY, fErr = parseIndexInterval(failedIndexesIntervals[failedPos], completions)
                                }
                        }
                }
        }
        return nil
}

func validateIndexesFormat(indexesStr string, completions int32) (int32, error) {
        if len(indexesStr) == 0 {
                return 0, nil
        }
        var lastIndex *int32
        var total int32
        for _, intervalStr := range strings.Split(indexesStr, ",") {
                x, y, err := parseIndexInterval(intervalStr, completions)
                if err != nil {
                        return 0, err
                }
                if lastIndex != nil && *lastIndex >= x {
                        return 0, fmt.Errorf("non-increasing order, previous: %d, current: %d", *lastIndex, x)
                }
                total += y - x + 1
                lastIndex = &y
        }
        return total, nil
}

func parseIndexInterval(intervalStr string, completions int32) (int32, int32, error) {
        limitsStr := strings.Split(intervalStr, "-")
        if len(limitsStr) > 2 {
                return 0, 0, fmt.Errorf("the fragment %q violates the requirement that an index interval can have at most two parts separated by '-'", intervalStr)
        }
        x, err := strconv.Atoi(limitsStr[0])
        if err != nil {
                return 0, 0, fmt.Errorf("cannot convert string to integer for index: %q", limitsStr[0])
        }
        if x >= int(completions) {
                return 0, 0, fmt.Errorf("too large index: %q", limitsStr[0])
        }
        if len(limitsStr) > 1 {
                y, err := strconv.Atoi(limitsStr[1])
                if err != nil {
                        return 0, 0, fmt.Errorf("cannot convert string to integer for index: %q", limitsStr[1])
                }
                if y >= int(completions) {
                        return 0, 0, fmt.Errorf("too large index: %q", limitsStr[1])
                }
                if x >= y {
                        return 0, 0, fmt.Errorf("non-increasing order, previous: %d, current: %d", x, y)
                }
                return int32(x), int32(y), nil
        }
        return int32(x), int32(x), nil
}

type JobValidationOptions struct {
        apivalidation.PodValidationOptions
        // Allow mutable node affinity, selector and tolerations of the template
        AllowMutableSchedulingDirectives bool
        // Require Job to have the label on batch.kubernetes.io/job-name and batch.kubernetes.io/controller-uid
        RequirePrefixedLabels bool
}

type JobStatusValidationOptions struct {
        RejectDecreasingSucceededCounter             bool
        RejectDecreasingFailedCounter                bool
        RejectDisablingTerminalCondition             bool
        RejectInvalidCompletedIndexes                bool
        RejectInvalidFailedIndexes                   bool
        RejectFailedIndexesOverlappingCompleted      bool
        RejectCompletedIndexesForNonIndexedJob       bool
        RejectFailedIndexesForNoBackoffLimitPerIndex bool
        RejectFailedJobWithoutFailureTarget          bool
        RejectCompleteJobWithoutSuccessCriteriaMet   bool
        RejectFinishedJobWithActivePods              bool
        RejectFinishedJobWithoutStartTime            bool
        RejectFinishedJobWithUncountedTerminatedPods bool
        RejectStartTimeUpdateForUnsuspendedJob       bool
        RejectCompletionTimeBeforeStartTime          bool
        RejectMutatingCompletionTime                 bool
        RejectCompleteJobWithoutCompletionTime       bool
        RejectNotCompleteJobWithCompletionTime       bool
        RejectCompleteJobWithFailedCondition         bool
        RejectCompleteJobWithFailureTargetCondition  bool
        AllowForSuccessCriteriaMetInExtendedScope    bool
        RejectMoreReadyThanActivePods                bool
        RejectFinishedJobWithTerminatingPods         bool
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package batch

import (
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        types "k8s.io/apimachinery/pkg/types"
        core "k8s.io/kubernetes/pkg/apis/core"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CronJob) DeepCopyInto(out *CronJob) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CronJob.
func (in *CronJob) DeepCopy() *CronJob {
        if in == nil {
                return nil
        }
        out := new(CronJob)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *CronJob) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CronJobList) DeepCopyInto(out *CronJobList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]CronJob, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CronJobList.
func (in *CronJobList) DeepCopy() *CronJobList {
        if in == nil {
                return nil
        }
        out := new(CronJobList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *CronJobList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CronJobSpec) DeepCopyInto(out *CronJobSpec) {
        *out = *in
        if in.TimeZone != nil {
                in, out := &in.TimeZone, &out.TimeZone
                *out = new(string)
                **out = **in
        }
        if in.StartingDeadlineSeconds != nil {
                in, out := &in.StartingDeadlineSeconds, &out.StartingDeadlineSeconds
                *out = new(int64)
                **out = **in
        }
        if in.Suspend != nil {
                in, out := &in.Suspend, &out.Suspend
                *out = new(bool)
                **out = **in
        }
        in.JobTemplate.DeepCopyInto(&out.JobTemplate)
        if in.SuccessfulJobsHistoryLimit != nil {
                in, out := &in.SuccessfulJobsHistoryLimit, &out.SuccessfulJobsHistoryLimit
                *out = new(int32)
                **out = **in
        }
        if in.FailedJobsHistoryLimit != nil {
                in, out := &in.FailedJobsHistoryLimit, &out.FailedJobsHistoryLimit
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CronJobSpec.
func (in *CronJobSpec) DeepCopy() *CronJobSpec {
        if in == nil {
                return nil
        }
        out := new(CronJobSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CronJobStatus) DeepCopyInto(out *CronJobStatus) {
        *out = *in
        if in.Active != nil {
                in, out := &in.Active, &out.Active
                *out = make([]core.ObjectReference, len(*in))
                copy(*out, *in)
        }
        if in.LastScheduleTime != nil {
                in, out := &in.LastScheduleTime, &out.LastScheduleTime
                *out = (*in).DeepCopy()
        }
        if in.LastSuccessfulTime != nil {
                in, out := &in.LastSuccessfulTime, &out.LastSuccessfulTime
                *out = (*in).DeepCopy()
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CronJobStatus.
func (in *CronJobStatus) DeepCopy() *CronJobStatus {
        if in == nil {
                return nil
        }
        out := new(CronJobStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Job) DeepCopyInto(out *Job) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Job.
func (in *Job) DeepCopy() *Job {
        if in == nil {
                return nil
        }
        out := new(Job)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Job) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *JobCondition) DeepCopyInto(out *JobCondition) {
        *out = *in
        in.LastProbeTime.DeepCopyInto(&out.LastProbeTime)
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JobCondition.
func (in *JobCondition) DeepCopy() *JobCondition {
        if in == nil {
                return nil
        }
        out := new(JobCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *JobList) DeepCopyInto(out *JobList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Job, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JobList.
func (in *JobList) DeepCopy() *JobList {
        if in == nil {
                return nil
        }
        out := new(JobList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *JobList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *JobSpec) DeepCopyInto(out *JobSpec) {
        *out = *in
        if in.Parallelism != nil {
                in, out := &in.Parallelism, &out.Parallelism
                *out = new(int32)
                **out = **in
        }
        if in.Completions != nil {
                in, out := &in.Completions, &out.Completions
                *out = new(int32)
                **out = **in
        }
        if in.PodFailurePolicy != nil {
                in, out := &in.PodFailurePolicy, &out.PodFailurePolicy
                *out = new(PodFailurePolicy)
                (*in).DeepCopyInto(*out)
        }
        if in.SuccessPolicy != nil {
                in, out := &in.SuccessPolicy, &out.SuccessPolicy
                *out = new(SuccessPolicy)
                (*in).DeepCopyInto(*out)
        }
        if in.ActiveDeadlineSeconds != nil {
                in, out := &in.ActiveDeadlineSeconds, &out.ActiveDeadlineSeconds
                *out = new(int64)
                **out = **in
        }
        if in.BackoffLimit != nil {
                in, out := &in.BackoffLimit, &out.BackoffLimit
                *out = new(int32)
                **out = **in
        }
        if in.BackoffLimitPerIndex != nil {
                in, out := &in.BackoffLimitPerIndex, &out.BackoffLimitPerIndex
                *out = new(int32)
                **out = **in
        }
        if in.MaxFailedIndexes != nil {
                in, out := &in.MaxFailedIndexes, &out.MaxFailedIndexes
                *out = new(int32)
                **out = **in
        }
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.ManualSelector != nil {
                in, out := &in.ManualSelector, &out.ManualSelector
                *out = new(bool)
                **out = **in
        }
        in.Template.DeepCopyInto(&out.Template)
        if in.TTLSecondsAfterFinished != nil {
                in, out := &in.TTLSecondsAfterFinished, &out.TTLSecondsAfterFinished
                *out = new(int32)
                **out = **in
        }
        if in.CompletionMode != nil {
                in, out := &in.CompletionMode, &out.CompletionMode
                *out = new(CompletionMode)
                **out = **in
        }
        if in.Suspend != nil {
                in, out := &in.Suspend, &out.Suspend
                *out = new(bool)
                **out = **in
        }
        if in.PodReplacementPolicy != nil {
                in, out := &in.PodReplacementPolicy, &out.PodReplacementPolicy
                *out = new(PodReplacementPolicy)
                **out = **in
        }
        if in.ManagedBy != nil {
                in, out := &in.ManagedBy, &out.ManagedBy
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JobSpec.
func (in *JobSpec) DeepCopy() *JobSpec {
        if in == nil {
                return nil
        }
        out := new(JobSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *JobStatus) DeepCopyInto(out *JobStatus) {
        *out = *in
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]JobCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.StartTime != nil {
                in, out := &in.StartTime, &out.StartTime
                *out = (*in).DeepCopy()
        }
        if in.CompletionTime != nil {
                in, out := &in.CompletionTime, &out.CompletionTime
                *out = (*in).DeepCopy()
        }
        if in.Terminating != nil {
                in, out := &in.Terminating, &out.Terminating
                *out = new(int32)
                **out = **in
        }
        if in.Ready != nil {
                in, out := &in.Ready, &out.Ready
                *out = new(int32)
                **out = **in
        }
        if in.FailedIndexes != nil {
                in, out := &in.FailedIndexes, &out.FailedIndexes
                *out = new(string)
                **out = **in
        }
        if in.UncountedTerminatedPods != nil {
                in, out := &in.UncountedTerminatedPods, &out.UncountedTerminatedPods
                *out = new(UncountedTerminatedPods)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JobStatus.
func (in *JobStatus) DeepCopy() *JobStatus {
        if in == nil {
                return nil
        }
        out := new(JobStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *JobTemplateSpec) DeepCopyInto(out *JobTemplateSpec) {
        *out = *in
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JobTemplateSpec.
func (in *JobTemplateSpec) DeepCopy() *JobTemplateSpec {
        if in == nil {
                return nil
        }
        out := new(JobTemplateSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodFailurePolicy) DeepCopyInto(out *PodFailurePolicy) {
        *out = *in
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]PodFailurePolicyRule, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodFailurePolicy.
func (in *PodFailurePolicy) DeepCopy() *PodFailurePolicy {
        if in == nil {
                return nil
        }
        out := new(PodFailurePolicy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodFailurePolicyOnExitCodesRequirement) DeepCopyInto(out *PodFailurePolicyOnExitCodesRequirement) {
        *out = *in
        if in.ContainerName != nil {
                in, out := &in.ContainerName, &out.ContainerName
                *out = new(string)
                **out = **in
        }
        if in.Values != nil {
                in, out := &in.Values, &out.Values
                *out = make([]int32, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodFailurePolicyOnExitCodesRequirement.
func (in *PodFailurePolicyOnExitCodesRequirement) DeepCopy() *PodFailurePolicyOnExitCodesRequirement {
        if in == nil {
                return nil
        }
        out := new(PodFailurePolicyOnExitCodesRequirement)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodFailurePolicyOnPodConditionsPattern) DeepCopyInto(out *PodFailurePolicyOnPodConditionsPattern) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodFailurePolicyOnPodConditionsPattern.
func (in *PodFailurePolicyOnPodConditionsPattern) DeepCopy() *PodFailurePolicyOnPodConditionsPattern {
        if in == nil {
                return nil
        }
        out := new(PodFailurePolicyOnPodConditionsPattern)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodFailurePolicyRule) DeepCopyInto(out *PodFailurePolicyRule) {
        *out = *in
        if in.OnExitCodes != nil {
                in, out := &in.OnExitCodes, &out.OnExitCodes
                *out = new(PodFailurePolicyOnExitCodesRequirement)
                (*in).DeepCopyInto(*out)
        }
        if in.OnPodConditions != nil {
                in, out := &in.OnPodConditions, &out.OnPodConditions
                *out = make([]PodFailurePolicyOnPodConditionsPattern, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodFailurePolicyRule.
func (in *PodFailurePolicyRule) DeepCopy() *PodFailurePolicyRule {
        if in == nil {
                return nil
        }
        out := new(PodFailurePolicyRule)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SuccessPolicy) DeepCopyInto(out *SuccessPolicy) {
        *out = *in
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]SuccessPolicyRule, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SuccessPolicy.
func (in *SuccessPolicy) DeepCopy() *SuccessPolicy {
        if in == nil {
                return nil
        }
        out := new(SuccessPolicy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SuccessPolicyRule) DeepCopyInto(out *SuccessPolicyRule) {
        *out = *in
        if in.SucceededIndexes != nil {
                in, out := &in.SucceededIndexes, &out.SucceededIndexes
                *out = new(string)
                **out = **in
        }
        if in.SucceededCount != nil {
                in, out := &in.SucceededCount, &out.SucceededCount
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SuccessPolicyRule.
func (in *SuccessPolicyRule) DeepCopy() *SuccessPolicyRule {
        if in == nil {
                return nil
        }
        out := new(SuccessPolicyRule)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *UncountedTerminatedPods) DeepCopyInto(out *UncountedTerminatedPods) {
        *out = *in
        if in.Succeeded != nil {
                in, out := &in.Succeeded, &out.Succeeded
                *out = make([]types.UID, len(*in))
                copy(*out, *in)
        }
        if in.Failed != nil {
                in, out := &in.Failed, &out.Failed
                *out = make([]types.UID, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UncountedTerminatedPods.
func (in *UncountedTerminatedPods) DeepCopy() *UncountedTerminatedPods {
        if in == nil {
                return nil
        }
        out := new(UncountedTerminatedPods)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        "time"

        "sigs.k8s.io/randfill"

        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
        "k8s.io/client-go/util/certificate/csr"
        "k8s.io/kubernetes/pkg/apis/certificates"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/utils/ptr"
)

// Funcs returns the fuzzer functions for the certificates api group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(obj *certificates.CertificateSigningRequestSpec, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        obj.Usages = []certificates.KeyUsage{certificates.UsageKeyEncipherment}
                        obj.SignerName = "example.com/custom-sample-signer"
                        obj.ExpirationSeconds = csr.DurationToExpirationSeconds(time.Hour + time.Minute + time.Second)
                },
                func(obj *certificates.CertificateSigningRequestCondition, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if len(obj.Status) == 0 {
                                obj.Status = api.ConditionTrue
                        }
                },
                func(obj *certificates.PodCertificateRequestSpec, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again

                        // MaxExpirationSeconds has a field defaulter, so we should make
                        // sure it's non-nil.  Otherwise,
                        // pkg/api/testing/serialization_test.go TestRoundTripTypes will
                        // fail with diffs due to the defaulting.
                        if obj.MaxExpirationSeconds == nil {
                                obj.MaxExpirationSeconds = ptr.To[int32](86400)
                        }
                },
        }
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package certificates

import (
        "crypto/x509"
        "encoding/pem"
        "errors"
        "fmt"
        "reflect"
        "strings"

        "k8s.io/apimachinery/pkg/util/sets"
)

// ParseCSR extracts the CSR from the bytes and decodes it.
func ParseCSR(pemBytes []byte) (*x509.CertificateRequest, error) {
        block, _ := pem.Decode(pemBytes)
        if block == nil || block.Type != "CERTIFICATE REQUEST" {
                return nil, errors.New("PEM block type must be CERTIFICATE REQUEST")
        }
        csr, err := x509.ParseCertificateRequest(block.Bytes)
        if err != nil {
                return nil, err
        }
        return csr, nil
}

var (
        organizationNotSystemNodesErr = fmt.Errorf("subject organization is not system:nodes")
        commonNameNotSystemNode       = fmt.Errorf("subject common name does not begin with system:node:")
        dnsOrIPSANRequiredErr         = fmt.Errorf("DNS or IP subjectAltName is required")
        dnsSANNotAllowedErr           = fmt.Errorf("DNS subjectAltNames are not allowed")
        emailSANNotAllowedErr         = fmt.Errorf("Email subjectAltNames are not allowed")
        ipSANNotAllowedErr            = fmt.Errorf("IP subjectAltNames are not allowed")
        uriSANNotAllowedErr           = fmt.Errorf("URI subjectAltNames are not allowed")
)

var (
        kubeletServingRequiredUsages = sets.NewString(
                string(UsageDigitalSignature),
                string(UsageKeyEncipherment),
                string(UsageServerAuth),
        )
        kubeletServingRequiredUsagesNoRSA = sets.NewString(
                string(UsageDigitalSignature),
                string(UsageServerAuth),
        )
)

func IsKubeletServingCSR(req *x509.CertificateRequest, usages sets.String) bool {
        return ValidateKubeletServingCSR(req, usages) == nil
}
func ValidateKubeletServingCSR(req *x509.CertificateRequest, usages sets.String) error {
        if !reflect.DeepEqual([]string{"system:nodes"}, req.Subject.Organization) {
                return organizationNotSystemNodesErr
        }

        // at least one of dnsNames or ipAddresses must be specified
        if len(req.DNSNames) == 0 && len(req.IPAddresses) == 0 {
                return dnsOrIPSANRequiredErr
        }

        if len(req.EmailAddresses) > 0 {
                return emailSANNotAllowedErr
        }
        if len(req.URIs) > 0 {
                return uriSANNotAllowedErr
        }

        if !kubeletServingRequiredUsages.Equal(usages) && !kubeletServingRequiredUsagesNoRSA.Equal(usages) {
                return fmt.Errorf("usages did not match %v", kubeletServingRequiredUsages.List())
        }

        if !strings.HasPrefix(req.Subject.CommonName, "system:node:") {
                return commonNameNotSystemNode
        }

        return nil
}

var (
        kubeletClientRequiredUsagesNoRSA = sets.NewString(
                string(UsageDigitalSignature),
                string(UsageClientAuth),
        )
        kubeletClientRequiredUsages = sets.NewString(
                string(UsageDigitalSignature),
                string(UsageKeyEncipherment),
                string(UsageClientAuth),
        )
)

func IsKubeletClientCSR(req *x509.CertificateRequest, usages sets.String) bool {
        return ValidateKubeletClientCSR(req, usages) == nil
}
func ValidateKubeletClientCSR(req *x509.CertificateRequest, usages sets.String) error {
        if !reflect.DeepEqual([]string{"system:nodes"}, req.Subject.Organization) {
                return organizationNotSystemNodesErr
        }

        if len(req.DNSNames) > 0 {
                return dnsSANNotAllowedErr
        }
        if len(req.EmailAddresses) > 0 {
                return emailSANNotAllowedErr
        }
        if len(req.IPAddresses) > 0 {
                return ipSANNotAllowedErr
        }
        if len(req.URIs) > 0 {
                return uriSANNotAllowedErr
        }

        if !strings.HasPrefix(req.Subject.CommonName, "system:node:") {
                return commonNameNotSystemNode
        }

        if !kubeletClientRequiredUsages.Equal(usages) && !kubeletClientRequiredUsagesNoRSA.Equal(usages) {
                return fmt.Errorf("usages did not match %v", kubeletClientRequiredUsages.List())
        }

        return nil
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

// Package install installs the certificates API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/certificates"
        v1 "k8s.io/kubernetes/pkg/apis/certificates/v1"
        "k8s.io/kubernetes/pkg/apis/certificates/v1alpha1"
        "k8s.io/kubernetes/pkg/apis/certificates/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(certificates.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1alpha1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion, v1alpha1.SchemeGroupVersion))
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package certificates

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

var (
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        AddToScheme   = SchemeBuilder.AddToScheme
)

// GroupName is the group name use in this package
const GroupName = "certificates.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &CertificateSigningRequest{},
                &CertificateSigningRequestList{},
                &ClusterTrustBundle{},
                &ClusterTrustBundleList{},
                &PodCertificateRequest{},
                &PodCertificateRequestList{},
        )
        return nil
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package v1

import (
        "fmt"

        "k8s.io/apimachinery/pkg/runtime"
)

func addConversionFuncs(scheme *runtime.Scheme) error {
        // Add field conversion funcs.
        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("CertificateSigningRequest"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name",
                                "spec.signerName":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                },
        )
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package v1

import (
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package v1

import (
        "crypto/x509"
        "encoding/pem"
        "errors"
)

// ParseCSR decodes a PEM encoded CSR
func ParseCSR(pemBytes []byte) (*x509.CertificateRequest, error) {
        // extract PEM from request object
        block, _ := pem.Decode(pemBytes)
        if block == nil || block.Type != "CERTIFICATE REQUEST" {
                return nil, errors.New("PEM block type must be CERTIFICATE REQUEST")
        }
        csr, err := x509.ParseCertificateRequest(block.Bytes)
        if err != nil {
                return nil, err
        }
        return csr, nil
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package v1

import (
        certificatesv1 "k8s.io/api/certificates/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "certificates.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &certificatesv1.SchemeBuilder

        // AddToScheme is a global function that registers this API group & version to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        certificatesv1 "k8s.io/api/certificates/v1"
        corev1 "k8s.io/api/core/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        certificates "k8s.io/kubernetes/pkg/apis/certificates"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*certificatesv1.CertificateSigningRequest)(nil), (*certificates.CertificateSigningRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(a.(*certificatesv1.CertificateSigningRequest), b.(*certificates.CertificateSigningRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequest)(nil), (*certificatesv1.CertificateSigningRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequest_To_v1_CertificateSigningRequest(a.(*certificates.CertificateSigningRequest), b.(*certificatesv1.CertificateSigningRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1.CertificateSigningRequestCondition)(nil), (*certificates.CertificateSigningRequestCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition(a.(*certificatesv1.CertificateSigningRequestCondition), b.(*certificates.CertificateSigningRequestCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequestCondition)(nil), (*certificatesv1.CertificateSigningRequestCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequestCondition_To_v1_CertificateSigningRequestCondition(a.(*certificates.CertificateSigningRequestCondition), b.(*certificatesv1.CertificateSigningRequestCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1.CertificateSigningRequestList)(nil), (*certificates.CertificateSigningRequestList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList(a.(*certificatesv1.CertificateSigningRequestList), b.(*certificates.CertificateSigningRequestList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequestList)(nil), (*certificatesv1.CertificateSigningRequestList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequestList_To_v1_CertificateSigningRequestList(a.(*certificates.CertificateSigningRequestList), b.(*certificatesv1.CertificateSigningRequestList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1.CertificateSigningRequestSpec)(nil), (*certificates.CertificateSigningRequestSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(a.(*certificatesv1.CertificateSigningRequestSpec), b.(*certificates.CertificateSigningRequestSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequestSpec)(nil), (*certificatesv1.CertificateSigningRequestSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequestSpec_To_v1_CertificateSigningRequestSpec(a.(*certificates.CertificateSigningRequestSpec), b.(*certificatesv1.CertificateSigningRequestSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1.CertificateSigningRequestStatus)(nil), (*certificates.CertificateSigningRequestStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(a.(*certificatesv1.CertificateSigningRequestStatus), b.(*certificates.CertificateSigningRequestStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequestStatus)(nil), (*certificatesv1.CertificateSigningRequestStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequestStatus_To_v1_CertificateSigningRequestStatus(a.(*certificates.CertificateSigningRequestStatus), b.(*certificatesv1.CertificateSigningRequestStatus), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(in *certificatesv1.CertificateSigningRequest, out *certificates.CertificateSigningRequest, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_CertificateSigningRequest_To_certificates_CertificateSigningRequest is an autogenerated conversion function.
func Convert_v1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(in *certificatesv1.CertificateSigningRequest, out *certificates.CertificateSigningRequest, s conversion.Scope) error {
        return autoConvert_v1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequest_To_v1_CertificateSigningRequest(in *certificates.CertificateSigningRequest, out *certificatesv1.CertificateSigningRequest, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_certificates_CertificateSigningRequestSpec_To_v1_CertificateSigningRequestSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_certificates_CertificateSigningRequestStatus_To_v1_CertificateSigningRequestStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_certificates_CertificateSigningRequest_To_v1_CertificateSigningRequest is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequest_To_v1_CertificateSigningRequest(in *certificates.CertificateSigningRequest, out *certificatesv1.CertificateSigningRequest, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequest_To_v1_CertificateSigningRequest(in, out, s)
}

func autoConvert_v1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition(in *certificatesv1.CertificateSigningRequestCondition, out *certificates.CertificateSigningRequestCondition, s conversion.Scope) error {
        out.Type = certificates.RequestConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.Reason = in.Reason
        out.Message = in.Message
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        return nil
}

// Convert_v1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition is an autogenerated conversion function.
func Convert_v1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition(in *certificatesv1.CertificateSigningRequestCondition, out *certificates.CertificateSigningRequestCondition, s conversion.Scope) error {
        return autoConvert_v1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequestCondition_To_v1_CertificateSigningRequestCondition(in *certificates.CertificateSigningRequestCondition, out *certificatesv1.CertificateSigningRequestCondition, s conversion.Scope) error {
        out.Type = certificatesv1.RequestConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.Reason = in.Reason
        out.Message = in.Message
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        return nil
}

// Convert_certificates_CertificateSigningRequestCondition_To_v1_CertificateSigningRequestCondition is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequestCondition_To_v1_CertificateSigningRequestCondition(in *certificates.CertificateSigningRequestCondition, out *certificatesv1.CertificateSigningRequestCondition, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequestCondition_To_v1_CertificateSigningRequestCondition(in, out, s)
}

func autoConvert_v1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList(in *certificatesv1.CertificateSigningRequestList, out *certificates.CertificateSigningRequestList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]certificates.CertificateSigningRequest)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList is an autogenerated conversion function.
func Convert_v1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList(in *certificatesv1.CertificateSigningRequestList, out *certificates.CertificateSigningRequestList, s conversion.Scope) error {
        return autoConvert_v1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequestList_To_v1_CertificateSigningRequestList(in *certificates.CertificateSigningRequestList, out *certificatesv1.CertificateSigningRequestList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]certificatesv1.CertificateSigningRequest)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_certificates_CertificateSigningRequestList_To_v1_CertificateSigningRequestList is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequestList_To_v1_CertificateSigningRequestList(in *certificates.CertificateSigningRequestList, out *certificatesv1.CertificateSigningRequestList, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequestList_To_v1_CertificateSigningRequestList(in, out, s)
}

func autoConvert_v1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(in *certificatesv1.CertificateSigningRequestSpec, out *certificates.CertificateSigningRequestSpec, s conversion.Scope) error {
        out.Request = *(*[]byte)(unsafe.Pointer(&in.Request))
        out.SignerName = in.SignerName
        out.ExpirationSeconds = (*int32)(unsafe.Pointer(in.ExpirationSeconds))
        out.Usages = *(*[]certificates.KeyUsage)(unsafe.Pointer(&in.Usages))
        out.Username = in.Username
        out.UID = in.UID
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]certificates.ExtraValue)(unsafe.Pointer(&in.Extra))
        return nil
}

// Convert_v1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec is an autogenerated conversion function.
func Convert_v1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(in *certificatesv1.CertificateSigningRequestSpec, out *certificates.CertificateSigningRequestSpec, s conversion.Scope) error {
        return autoConvert_v1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequestSpec_To_v1_CertificateSigningRequestSpec(in *certificates.CertificateSigningRequestSpec, out *certificatesv1.CertificateSigningRequestSpec, s conversion.Scope) error {
        out.Request = *(*[]byte)(unsafe.Pointer(&in.Request))
        out.SignerName = in.SignerName
        out.ExpirationSeconds = (*int32)(unsafe.Pointer(in.ExpirationSeconds))
        out.Usages = *(*[]certificatesv1.KeyUsage)(unsafe.Pointer(&in.Usages))
        out.Username = in.Username
        out.UID = in.UID
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]certificatesv1.ExtraValue)(unsafe.Pointer(&in.Extra))
        return nil
}

// Convert_certificates_CertificateSigningRequestSpec_To_v1_CertificateSigningRequestSpec is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequestSpec_To_v1_CertificateSigningRequestSpec(in *certificates.CertificateSigningRequestSpec, out *certificatesv1.CertificateSigningRequestSpec, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequestSpec_To_v1_CertificateSigningRequestSpec(in, out, s)
}

func autoConvert_v1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(in *certificatesv1.CertificateSigningRequestStatus, out *certificates.CertificateSigningRequestStatus, s conversion.Scope) error {
        out.Conditions = *(*[]certificates.CertificateSigningRequestCondition)(unsafe.Pointer(&in.Conditions))
        out.Certificate = *(*[]byte)(unsafe.Pointer(&in.Certificate))
        return nil
}

// Convert_v1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus is an autogenerated conversion function.
func Convert_v1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(in *certificatesv1.CertificateSigningRequestStatus, out *certificates.CertificateSigningRequestStatus, s conversion.Scope) error {
        return autoConvert_v1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequestStatus_To_v1_CertificateSigningRequestStatus(in *certificates.CertificateSigningRequestStatus, out *certificatesv1.CertificateSigningRequestStatus, s conversion.Scope) error {
        out.Conditions = *(*[]certificatesv1.CertificateSigningRequestCondition)(unsafe.Pointer(&in.Conditions))
        out.Certificate = *(*[]byte)(unsafe.Pointer(&in.Certificate))
        return nil
}

// Convert_certificates_CertificateSigningRequestStatus_To_v1_CertificateSigningRequestStatus is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequestStatus_To_v1_CertificateSigningRequestStatus(in *certificates.CertificateSigningRequestStatus, out *certificatesv1.CertificateSigningRequestStatus, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequestStatus_To_v1_CertificateSigningRequestStatus(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 validation-gen. DO NOT EDIT.

package v1

import (
        context "context"
        fmt "fmt"

        certificatesv1 "k8s.io/api/certificates/v1"
        equality "k8s.io/apimachinery/pkg/api/equality"
        operation "k8s.io/apimachinery/pkg/api/operation"
        safe "k8s.io/apimachinery/pkg/api/safe"
        validate "k8s.io/apimachinery/pkg/api/validate"
        runtime "k8s.io/apimachinery/pkg/runtime"
        field "k8s.io/apimachinery/pkg/util/validation/field"
)

func init() { localSchemeBuilder.Register(RegisterValidations) }

// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
        scheme.AddValidationFunc((*certificatesv1.CertificateSigningRequest)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/", "/approval", "/status":
                        return Validate_CertificateSigningRequest(ctx, op, nil /* fldPath */, obj.(*certificatesv1.CertificateSigningRequest), safe.Cast[*certificatesv1.CertificateSigningRequest](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        scheme.AddValidationFunc((*certificatesv1.CertificateSigningRequestList)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/":
                        return Validate_CertificateSigningRequestList(ctx, op, nil /* fldPath */, obj.(*certificatesv1.CertificateSigningRequestList), safe.Cast[*certificatesv1.CertificateSigningRequestList](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        return nil
}

func Validate_CertificateSigningRequest(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *certificatesv1.CertificateSigningRequest) (errs field.ErrorList) {
        // field certificatesv1.CertificateSigningRequest.TypeMeta has no validation
        // field certificatesv1.CertificateSigningRequest.ObjectMeta has no validation
        // field certificatesv1.CertificateSigningRequest.Spec has no validation

        // field certificatesv1.CertificateSigningRequest.Status
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *certificatesv1.CertificateSigningRequestStatus) (errs field.ErrorList) {
                        errs = append(errs, Validate_CertificateSigningRequestStatus(ctx, op, fldPath, obj, oldObj)...)
                        return
                }(fldPath.Child("status"), &obj.Status, safe.Field(oldObj, func(oldObj *certificatesv1.CertificateSigningRequest) *certificatesv1.CertificateSigningRequestStatus {
                        return &oldObj.Status
                }))...)

        return errs
}

func Validate_CertificateSigningRequestList(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *certificatesv1.CertificateSigningRequestList) (errs field.ErrorList) {
        // field certificatesv1.CertificateSigningRequestList.TypeMeta has no validation
        // field certificatesv1.CertificateSigningRequestList.ListMeta has no validation

        // field certificatesv1.CertificateSigningRequestList.Items
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj []certificatesv1.CertificateSigningRequest) (errs field.ErrorList) {
                        if op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
                                return nil // no changes
                        }
                        errs = append(errs, validate.EachSliceVal(ctx, op, fldPath, obj, oldObj, nil, nil, Validate_CertificateSigningRequest)...)
                        return
                }(fldPath.Child("items"), obj.Items, safe.Field(oldObj, func(oldObj *certificatesv1.CertificateSigningRequestList) []certificatesv1.CertificateSigningRequest {
                        return oldObj.Items
                }))...)

        return errs
}

var zeroOrOneOfMembershipFor_k8s_io_api_certificates_v1_CertificateSigningRequestStatus_Conditions_ = validate.NewUnionMembership([2]string{"Conditions[{\"type\": \"Approved\"}]", ""}, [2]string{"Conditions[{\"type\": \"Denied\"}]", ""})

func Validate_CertificateSigningRequestStatus(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *certificatesv1.CertificateSigningRequestStatus) (errs field.ErrorList) {
        // field certificatesv1.CertificateSigningRequestStatus.Conditions
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj []certificatesv1.CertificateSigningRequestCondition) (errs field.ErrorList) {
                        if op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
                                return nil // no changes
                        }
                        if e := validate.OptionalSlice(ctx, op, fldPath, obj, oldObj); len(e) != 0 {
                                return // do not proceed
                        }
                        errs = append(errs, validate.ZeroOrOneOfUnion(ctx, op, fldPath, obj, oldObj, zeroOrOneOfMembershipFor_k8s_io_api_certificates_v1_CertificateSigningRequestStatus_Conditions_, func(list []certificatesv1.CertificateSigningRequestCondition) bool {
                                for i := range list {
                                        if list[i].Type == "Approved" {
                                                return true
                                        }
                                }
                                return false
                        }, func(list []certificatesv1.CertificateSigningRequestCondition) bool {
                                for i := range list {
                                        if list[i].Type == "Denied" {
                                                return true
                                        }
                                }
                                return false
                        })...)
                        return
                }(fldPath.Child("conditions"), obj.Conditions, safe.Field(oldObj, func(oldObj *certificatesv1.CertificateSigningRequestStatus) []certificatesv1.CertificateSigningRequestCondition {
                        return oldObj.Conditions
                }))...)

        // field certificatesv1.CertificateSigningRequestStatus.Certificate has no validation
        return errs
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package v1alpha1

import (
        "fmt"

        "k8s.io/apimachinery/pkg/runtime"
)

func addConversionFuncs(scheme *runtime.Scheme) error {
        err := scheme.AddFieldLabelConversionFunc(
                SchemeGroupVersion.WithKind("ClusterTrustBundle"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name", "spec.signerName":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                },
        )
        if err != nil {
                return fmt.Errorf("while adding ClusterTrustBundle field label conversion func: %w", err)
        }

        err = scheme.AddFieldLabelConversionFunc(
                SchemeGroupVersion.WithKind("PodCertificateRequest"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name", "spec.signerName", "spec.podName", "spec.nodeName":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                },
        )
        if err != nil {
                return fmt.Errorf("while adding PodCertificateRequest field label conversion func: %w", err)
        }

        return nil
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package v1alpha1

import (
        "k8s.io/apimachinery/pkg/runtime"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package v1alpha1

import (
        certificatesv1alpha1 "k8s.io/api/certificates/v1alpha1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name used in this package.
const GroupName = "certificates.k8s.io"

// SchemeGroupVersion is the group and version used in this package.
var SchemeGroupVersion = schema.GroupVersion{
        Group:   GroupName,
        Version: "v1alpha1",
}

var (
        localSchemeBuilder = &certificatesv1alpha1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1alpha1

import (
        unsafe "unsafe"

        certificatesv1alpha1 "k8s.io/api/certificates/v1alpha1"
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        types "k8s.io/apimachinery/pkg/types"
        certificates "k8s.io/kubernetes/pkg/apis/certificates"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*certificatesv1alpha1.ClusterTrustBundle)(nil), (*certificates.ClusterTrustBundle)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ClusterTrustBundle_To_certificates_ClusterTrustBundle(a.(*certificatesv1alpha1.ClusterTrustBundle), b.(*certificates.ClusterTrustBundle), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.ClusterTrustBundle)(nil), (*certificatesv1alpha1.ClusterTrustBundle)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_ClusterTrustBundle_To_v1alpha1_ClusterTrustBundle(a.(*certificates.ClusterTrustBundle), b.(*certificatesv1alpha1.ClusterTrustBundle), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1alpha1.ClusterTrustBundleList)(nil), (*certificates.ClusterTrustBundleList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList(a.(*certificatesv1alpha1.ClusterTrustBundleList), b.(*certificates.ClusterTrustBundleList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.ClusterTrustBundleList)(nil), (*certificatesv1alpha1.ClusterTrustBundleList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_ClusterTrustBundleList_To_v1alpha1_ClusterTrustBundleList(a.(*certificates.ClusterTrustBundleList), b.(*certificatesv1alpha1.ClusterTrustBundleList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1alpha1.ClusterTrustBundleSpec)(nil), (*certificates.ClusterTrustBundleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(a.(*certificatesv1alpha1.ClusterTrustBundleSpec), b.(*certificates.ClusterTrustBundleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.ClusterTrustBundleSpec)(nil), (*certificatesv1alpha1.ClusterTrustBundleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_ClusterTrustBundleSpec_To_v1alpha1_ClusterTrustBundleSpec(a.(*certificates.ClusterTrustBundleSpec), b.(*certificatesv1alpha1.ClusterTrustBundleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1alpha1.PodCertificateRequest)(nil), (*certificates.PodCertificateRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_PodCertificateRequest_To_certificates_PodCertificateRequest(a.(*certificatesv1alpha1.PodCertificateRequest), b.(*certificates.PodCertificateRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.PodCertificateRequest)(nil), (*certificatesv1alpha1.PodCertificateRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_PodCertificateRequest_To_v1alpha1_PodCertificateRequest(a.(*certificates.PodCertificateRequest), b.(*certificatesv1alpha1.PodCertificateRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1alpha1.PodCertificateRequestList)(nil), (*certificates.PodCertificateRequestList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_PodCertificateRequestList_To_certificates_PodCertificateRequestList(a.(*certificatesv1alpha1.PodCertificateRequestList), b.(*certificates.PodCertificateRequestList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.PodCertificateRequestList)(nil), (*certificatesv1alpha1.PodCertificateRequestList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_PodCertificateRequestList_To_v1alpha1_PodCertificateRequestList(a.(*certificates.PodCertificateRequestList), b.(*certificatesv1alpha1.PodCertificateRequestList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1alpha1.PodCertificateRequestSpec)(nil), (*certificates.PodCertificateRequestSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_PodCertificateRequestSpec_To_certificates_PodCertificateRequestSpec(a.(*certificatesv1alpha1.PodCertificateRequestSpec), b.(*certificates.PodCertificateRequestSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.PodCertificateRequestSpec)(nil), (*certificatesv1alpha1.PodCertificateRequestSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_PodCertificateRequestSpec_To_v1alpha1_PodCertificateRequestSpec(a.(*certificates.PodCertificateRequestSpec), b.(*certificatesv1alpha1.PodCertificateRequestSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1alpha1.PodCertificateRequestStatus)(nil), (*certificates.PodCertificateRequestStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha1_PodCertificateRequestStatus_To_certificates_PodCertificateRequestStatus(a.(*certificatesv1alpha1.PodCertificateRequestStatus), b.(*certificates.PodCertificateRequestStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.PodCertificateRequestStatus)(nil), (*certificatesv1alpha1.PodCertificateRequestStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_PodCertificateRequestStatus_To_v1alpha1_PodCertificateRequestStatus(a.(*certificates.PodCertificateRequestStatus), b.(*certificatesv1alpha1.PodCertificateRequestStatus), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1alpha1_ClusterTrustBundle_To_certificates_ClusterTrustBundle(in *certificatesv1alpha1.ClusterTrustBundle, out *certificates.ClusterTrustBundle, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1alpha1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_ClusterTrustBundle_To_certificates_ClusterTrustBundle is an autogenerated conversion function.
func Convert_v1alpha1_ClusterTrustBundle_To_certificates_ClusterTrustBundle(in *certificatesv1alpha1.ClusterTrustBundle, out *certificates.ClusterTrustBundle, s conversion.Scope) error {
        return autoConvert_v1alpha1_ClusterTrustBundle_To_certificates_ClusterTrustBundle(in, out, s)
}

func autoConvert_certificates_ClusterTrustBundle_To_v1alpha1_ClusterTrustBundle(in *certificates.ClusterTrustBundle, out *certificatesv1alpha1.ClusterTrustBundle, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_certificates_ClusterTrustBundleSpec_To_v1alpha1_ClusterTrustBundleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_certificates_ClusterTrustBundle_To_v1alpha1_ClusterTrustBundle is an autogenerated conversion function.
func Convert_certificates_ClusterTrustBundle_To_v1alpha1_ClusterTrustBundle(in *certificates.ClusterTrustBundle, out *certificatesv1alpha1.ClusterTrustBundle, s conversion.Scope) error {
        return autoConvert_certificates_ClusterTrustBundle_To_v1alpha1_ClusterTrustBundle(in, out, s)
}

func autoConvert_v1alpha1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList(in *certificatesv1alpha1.ClusterTrustBundleList, out *certificates.ClusterTrustBundleList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]certificates.ClusterTrustBundle)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1alpha1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList is an autogenerated conversion function.
func Convert_v1alpha1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList(in *certificatesv1alpha1.ClusterTrustBundleList, out *certificates.ClusterTrustBundleList, s conversion.Scope) error {
        return autoConvert_v1alpha1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList(in, out, s)
}

func autoConvert_certificates_ClusterTrustBundleList_To_v1alpha1_ClusterTrustBundleList(in *certificates.ClusterTrustBundleList, out *certificatesv1alpha1.ClusterTrustBundleList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]certificatesv1alpha1.ClusterTrustBundle)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_certificates_ClusterTrustBundleList_To_v1alpha1_ClusterTrustBundleList is an autogenerated conversion function.
func Convert_certificates_ClusterTrustBundleList_To_v1alpha1_ClusterTrustBundleList(in *certificates.ClusterTrustBundleList, out *certificatesv1alpha1.ClusterTrustBundleList, s conversion.Scope) error {
        return autoConvert_certificates_ClusterTrustBundleList_To_v1alpha1_ClusterTrustBundleList(in, out, s)
}

func autoConvert_v1alpha1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(in *certificatesv1alpha1.ClusterTrustBundleSpec, out *certificates.ClusterTrustBundleSpec, s conversion.Scope) error {
        out.SignerName = in.SignerName
        out.TrustBundle = in.TrustBundle
        return nil
}

// Convert_v1alpha1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec is an autogenerated conversion function.
func Convert_v1alpha1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(in *certificatesv1alpha1.ClusterTrustBundleSpec, out *certificates.ClusterTrustBundleSpec, s conversion.Scope) error {
        return autoConvert_v1alpha1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(in, out, s)
}

func autoConvert_certificates_ClusterTrustBundleSpec_To_v1alpha1_ClusterTrustBundleSpec(in *certificates.ClusterTrustBundleSpec, out *certificatesv1alpha1.ClusterTrustBundleSpec, s conversion.Scope) error {
        out.SignerName = in.SignerName
        out.TrustBundle = in.TrustBundle
        return nil
}

// Convert_certificates_ClusterTrustBundleSpec_To_v1alpha1_ClusterTrustBundleSpec is an autogenerated conversion function.
func Convert_certificates_ClusterTrustBundleSpec_To_v1alpha1_ClusterTrustBundleSpec(in *certificates.ClusterTrustBundleSpec, out *certificatesv1alpha1.ClusterTrustBundleSpec, s conversion.Scope) error {
        return autoConvert_certificates_ClusterTrustBundleSpec_To_v1alpha1_ClusterTrustBundleSpec(in, out, s)
}

func autoConvert_v1alpha1_PodCertificateRequest_To_certificates_PodCertificateRequest(in *certificatesv1alpha1.PodCertificateRequest, out *certificates.PodCertificateRequest, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1alpha1_PodCertificateRequestSpec_To_certificates_PodCertificateRequestSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1alpha1_PodCertificateRequestStatus_To_certificates_PodCertificateRequestStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha1_PodCertificateRequest_To_certificates_PodCertificateRequest is an autogenerated conversion function.
func Convert_v1alpha1_PodCertificateRequest_To_certificates_PodCertificateRequest(in *certificatesv1alpha1.PodCertificateRequest, out *certificates.PodCertificateRequest, s conversion.Scope) error {
        return autoConvert_v1alpha1_PodCertificateRequest_To_certificates_PodCertificateRequest(in, out, s)
}

func autoConvert_certificates_PodCertificateRequest_To_v1alpha1_PodCertificateRequest(in *certificates.PodCertificateRequest, out *certificatesv1alpha1.PodCertificateRequest, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_certificates_PodCertificateRequestSpec_To_v1alpha1_PodCertificateRequestSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_certificates_PodCertificateRequestStatus_To_v1alpha1_PodCertificateRequestStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_certificates_PodCertificateRequest_To_v1alpha1_PodCertificateRequest is an autogenerated conversion function.
func Convert_certificates_PodCertificateRequest_To_v1alpha1_PodCertificateRequest(in *certificates.PodCertificateRequest, out *certificatesv1alpha1.PodCertificateRequest, s conversion.Scope) error {
        return autoConvert_certificates_PodCertificateRequest_To_v1alpha1_PodCertificateRequest(in, out, s)
}

func autoConvert_v1alpha1_PodCertificateRequestList_To_certificates_PodCertificateRequestList(in *certificatesv1alpha1.PodCertificateRequestList, out *certificates.PodCertificateRequestList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]certificates.PodCertificateRequest)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1alpha1_PodCertificateRequestList_To_certificates_PodCertificateRequestList is an autogenerated conversion function.
func Convert_v1alpha1_PodCertificateRequestList_To_certificates_PodCertificateRequestList(in *certificatesv1alpha1.PodCertificateRequestList, out *certificates.PodCertificateRequestList, s conversion.Scope) error {
        return autoConvert_v1alpha1_PodCertificateRequestList_To_certificates_PodCertificateRequestList(in, out, s)
}

func autoConvert_certificates_PodCertificateRequestList_To_v1alpha1_PodCertificateRequestList(in *certificates.PodCertificateRequestList, out *certificatesv1alpha1.PodCertificateRequestList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]certificatesv1alpha1.PodCertificateRequest)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_certificates_PodCertificateRequestList_To_v1alpha1_PodCertificateRequestList is an autogenerated conversion function.
func Convert_certificates_PodCertificateRequestList_To_v1alpha1_PodCertificateRequestList(in *certificates.PodCertificateRequestList, out *certificatesv1alpha1.PodCertificateRequestList, s conversion.Scope) error {
        return autoConvert_certificates_PodCertificateRequestList_To_v1alpha1_PodCertificateRequestList(in, out, s)
}

func autoConvert_v1alpha1_PodCertificateRequestSpec_To_certificates_PodCertificateRequestSpec(in *certificatesv1alpha1.PodCertificateRequestSpec, out *certificates.PodCertificateRequestSpec, s conversion.Scope) error {
        out.SignerName = in.SignerName
        out.PodName = in.PodName
        out.PodUID = types.UID(in.PodUID)
        out.ServiceAccountName = in.ServiceAccountName
        out.ServiceAccountUID = types.UID(in.ServiceAccountUID)
        out.NodeName = types.NodeName(in.NodeName)
        out.NodeUID = types.UID(in.NodeUID)
        out.MaxExpirationSeconds = (*int32)(unsafe.Pointer(in.MaxExpirationSeconds))
        out.PKIXPublicKey = *(*[]byte)(unsafe.Pointer(&in.PKIXPublicKey))
        out.ProofOfPossession = *(*[]byte)(unsafe.Pointer(&in.ProofOfPossession))
        return nil
}

// Convert_v1alpha1_PodCertificateRequestSpec_To_certificates_PodCertificateRequestSpec is an autogenerated conversion function.
func Convert_v1alpha1_PodCertificateRequestSpec_To_certificates_PodCertificateRequestSpec(in *certificatesv1alpha1.PodCertificateRequestSpec, out *certificates.PodCertificateRequestSpec, s conversion.Scope) error {
        return autoConvert_v1alpha1_PodCertificateRequestSpec_To_certificates_PodCertificateRequestSpec(in, out, s)
}

func autoConvert_certificates_PodCertificateRequestSpec_To_v1alpha1_PodCertificateRequestSpec(in *certificates.PodCertificateRequestSpec, out *certificatesv1alpha1.PodCertificateRequestSpec, s conversion.Scope) error {
        out.SignerName = in.SignerName
        out.PodName = in.PodName
        out.PodUID = types.UID(in.PodUID)
        out.ServiceAccountName = in.ServiceAccountName
        out.ServiceAccountUID = types.UID(in.ServiceAccountUID)
        out.NodeName = types.NodeName(in.NodeName)
        out.NodeUID = types.UID(in.NodeUID)
        out.MaxExpirationSeconds = (*int32)(unsafe.Pointer(in.MaxExpirationSeconds))
        out.PKIXPublicKey = *(*[]byte)(unsafe.Pointer(&in.PKIXPublicKey))
        out.ProofOfPossession = *(*[]byte)(unsafe.Pointer(&in.ProofOfPossession))
        return nil
}

// Convert_certificates_PodCertificateRequestSpec_To_v1alpha1_PodCertificateRequestSpec is an autogenerated conversion function.
func Convert_certificates_PodCertificateRequestSpec_To_v1alpha1_PodCertificateRequestSpec(in *certificates.PodCertificateRequestSpec, out *certificatesv1alpha1.PodCertificateRequestSpec, s conversion.Scope) error {
        return autoConvert_certificates_PodCertificateRequestSpec_To_v1alpha1_PodCertificateRequestSpec(in, out, s)
}

func autoConvert_v1alpha1_PodCertificateRequestStatus_To_certificates_PodCertificateRequestStatus(in *certificatesv1alpha1.PodCertificateRequestStatus, out *certificates.PodCertificateRequestStatus, s conversion.Scope) error {
        out.Conditions = *(*[]v1.Condition)(unsafe.Pointer(&in.Conditions))
        out.CertificateChain = in.CertificateChain
        out.NotBefore = (*v1.Time)(unsafe.Pointer(in.NotBefore))
        out.BeginRefreshAt = (*v1.Time)(unsafe.Pointer(in.BeginRefreshAt))
        out.NotAfter = (*v1.Time)(unsafe.Pointer(in.NotAfter))
        return nil
}

// Convert_v1alpha1_PodCertificateRequestStatus_To_certificates_PodCertificateRequestStatus is an autogenerated conversion function.
func Convert_v1alpha1_PodCertificateRequestStatus_To_certificates_PodCertificateRequestStatus(in *certificatesv1alpha1.PodCertificateRequestStatus, out *certificates.PodCertificateRequestStatus, s conversion.Scope) error {
        return autoConvert_v1alpha1_PodCertificateRequestStatus_To_certificates_PodCertificateRequestStatus(in, out, s)
}

func autoConvert_certificates_PodCertificateRequestStatus_To_v1alpha1_PodCertificateRequestStatus(in *certificates.PodCertificateRequestStatus, out *certificatesv1alpha1.PodCertificateRequestStatus, s conversion.Scope) error {
        out.Conditions = *(*[]v1.Condition)(unsafe.Pointer(&in.Conditions))
        out.CertificateChain = in.CertificateChain
        out.NotBefore = (*v1.Time)(unsafe.Pointer(in.NotBefore))
        out.BeginRefreshAt = (*v1.Time)(unsafe.Pointer(in.BeginRefreshAt))
        out.NotAfter = (*v1.Time)(unsafe.Pointer(in.NotAfter))
        return nil
}

// Convert_certificates_PodCertificateRequestStatus_To_v1alpha1_PodCertificateRequestStatus is an autogenerated conversion function.
func Convert_certificates_PodCertificateRequestStatus_To_v1alpha1_PodCertificateRequestStatus(in *certificates.PodCertificateRequestStatus, out *certificatesv1alpha1.PodCertificateRequestStatus, s conversion.Scope) error {
        return autoConvert_certificates_PodCertificateRequestStatus_To_v1alpha1_PodCertificateRequestStatus(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1alpha1

import (
        certificatesv1alpha1 "k8s.io/api/certificates/v1alpha1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&certificatesv1alpha1.PodCertificateRequest{}, func(obj interface{}) {
                SetObjectDefaults_PodCertificateRequest(obj.(*certificatesv1alpha1.PodCertificateRequest))
        })
        scheme.AddTypeDefaultingFunc(&certificatesv1alpha1.PodCertificateRequestList{}, func(obj interface{}) {
                SetObjectDefaults_PodCertificateRequestList(obj.(*certificatesv1alpha1.PodCertificateRequestList))
        })
        return nil
}

func SetObjectDefaults_PodCertificateRequest(in *certificatesv1alpha1.PodCertificateRequest) {
        if in.Spec.MaxExpirationSeconds == nil {
                var ptrVar1 int32 = 86400
                in.Spec.MaxExpirationSeconds = &ptrVar1
        }
}

func SetObjectDefaults_PodCertificateRequestList(in *certificatesv1alpha1.PodCertificateRequestList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_PodCertificateRequest(a)
        }
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 validation-gen. DO NOT EDIT.

package v1alpha1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

func init() { localSchemeBuilder.Register(RegisterValidations) }

// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
        return nil
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "fmt"

        "k8s.io/apimachinery/pkg/runtime"
)

func addConversionFuncs(scheme *runtime.Scheme) error {
        // Add field conversion funcs.
        err := scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("CertificateSigningRequest"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name",
                                "spec.signerName":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                },
        )
        if err != nil {
                return err
        }

        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("ClusterTrustBundle"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name",
                                "spec.signerName":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                },
        )
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "crypto/x509"

        certificatesv1beta1 "k8s.io/api/certificates/v1beta1"
        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/util/sets"
        certificates "k8s.io/kubernetes/pkg/apis/certificates"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_CertificateSigningRequestSpec(obj *certificatesv1beta1.CertificateSigningRequestSpec) {
        if obj.Usages == nil {
                obj.Usages = []certificatesv1beta1.KeyUsage{certificatesv1beta1.UsageDigitalSignature, certificatesv1beta1.UsageKeyEncipherment}
        }

        if obj.SignerName == nil {
                signerName := DefaultSignerNameFromSpec(obj)
                obj.SignerName = &signerName
        }
}

func SetDefaults_CertificateSigningRequestCondition(obj *certificatesv1beta1.CertificateSigningRequestCondition) {
        if len(obj.Status) == 0 {
                obj.Status = v1.ConditionTrue
        }
}

// DefaultSignerNameFromSpec will determine the signerName that should be set
// by attempting to inspect the 'request' content and the spec options.
func DefaultSignerNameFromSpec(obj *certificatesv1beta1.CertificateSigningRequestSpec) string {
        csr, err := ParseCSR(obj.Request)
        switch {
        case err != nil:
                // Set the signerName to 'legacy-unknown' as the CSR could not be
                // recognised.
                return certificatesv1beta1.LegacyUnknownSignerName
        case IsKubeletClientCSR(csr, obj.Usages):
                return certificatesv1beta1.KubeAPIServerClientKubeletSignerName
        case IsKubeletServingCSR(csr, obj.Usages):
                return certificatesv1beta1.KubeletServingSignerName
        default:
                return certificatesv1beta1.LegacyUnknownSignerName
        }
}

func IsKubeletServingCSR(req *x509.CertificateRequest, usages []certificatesv1beta1.KeyUsage) bool {
        return certificates.IsKubeletServingCSR(req, usagesToSet(usages))
}

func IsKubeletClientCSR(req *x509.CertificateRequest, usages []certificatesv1beta1.KeyUsage) bool {
        return certificates.IsKubeletClientCSR(req, usagesToSet(usages))
}

func usagesToSet(usages []certificatesv1beta1.KeyUsage) sets.String {
        result := sets.NewString()
        for _, usage := range usages {
                result.Insert(string(usage))
        }
        return result
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "crypto/x509"
        "encoding/pem"
        "errors"
)

// ParseCSR decodes a PEM encoded CSR
func ParseCSR(pemBytes []byte) (*x509.CertificateRequest, error) {
        // extract PEM from request object
        block, _ := pem.Decode(pemBytes)
        if block == nil || block.Type != "CERTIFICATE REQUEST" {
                return nil, errors.New("PEM block type must be CERTIFICATE REQUEST")
        }
        csr, err := x509.ParseCertificateRequest(block.Bytes)
        if err != nil {
                return nil, err
        }
        return csr, nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        certificatesv1beta1 "k8s.io/api/certificates/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "certificates.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &certificatesv1beta1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        certificatesv1beta1 "k8s.io/api/certificates/v1beta1"
        v1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        certificates "k8s.io/kubernetes/pkg/apis/certificates"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*certificatesv1beta1.CertificateSigningRequest)(nil), (*certificates.CertificateSigningRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(a.(*certificatesv1beta1.CertificateSigningRequest), b.(*certificates.CertificateSigningRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequest)(nil), (*certificatesv1beta1.CertificateSigningRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequest_To_v1beta1_CertificateSigningRequest(a.(*certificates.CertificateSigningRequest), b.(*certificatesv1beta1.CertificateSigningRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1beta1.CertificateSigningRequestCondition)(nil), (*certificates.CertificateSigningRequestCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition(a.(*certificatesv1beta1.CertificateSigningRequestCondition), b.(*certificates.CertificateSigningRequestCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequestCondition)(nil), (*certificatesv1beta1.CertificateSigningRequestCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequestCondition_To_v1beta1_CertificateSigningRequestCondition(a.(*certificates.CertificateSigningRequestCondition), b.(*certificatesv1beta1.CertificateSigningRequestCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1beta1.CertificateSigningRequestList)(nil), (*certificates.CertificateSigningRequestList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList(a.(*certificatesv1beta1.CertificateSigningRequestList), b.(*certificates.CertificateSigningRequestList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequestList)(nil), (*certificatesv1beta1.CertificateSigningRequestList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequestList_To_v1beta1_CertificateSigningRequestList(a.(*certificates.CertificateSigningRequestList), b.(*certificatesv1beta1.CertificateSigningRequestList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1beta1.CertificateSigningRequestSpec)(nil), (*certificates.CertificateSigningRequestSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(a.(*certificatesv1beta1.CertificateSigningRequestSpec), b.(*certificates.CertificateSigningRequestSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequestSpec)(nil), (*certificatesv1beta1.CertificateSigningRequestSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequestSpec_To_v1beta1_CertificateSigningRequestSpec(a.(*certificates.CertificateSigningRequestSpec), b.(*certificatesv1beta1.CertificateSigningRequestSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1beta1.CertificateSigningRequestStatus)(nil), (*certificates.CertificateSigningRequestStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(a.(*certificatesv1beta1.CertificateSigningRequestStatus), b.(*certificates.CertificateSigningRequestStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.CertificateSigningRequestStatus)(nil), (*certificatesv1beta1.CertificateSigningRequestStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_CertificateSigningRequestStatus_To_v1beta1_CertificateSigningRequestStatus(a.(*certificates.CertificateSigningRequestStatus), b.(*certificatesv1beta1.CertificateSigningRequestStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1beta1.ClusterTrustBundle)(nil), (*certificates.ClusterTrustBundle)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ClusterTrustBundle_To_certificates_ClusterTrustBundle(a.(*certificatesv1beta1.ClusterTrustBundle), b.(*certificates.ClusterTrustBundle), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.ClusterTrustBundle)(nil), (*certificatesv1beta1.ClusterTrustBundle)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_ClusterTrustBundle_To_v1beta1_ClusterTrustBundle(a.(*certificates.ClusterTrustBundle), b.(*certificatesv1beta1.ClusterTrustBundle), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1beta1.ClusterTrustBundleList)(nil), (*certificates.ClusterTrustBundleList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList(a.(*certificatesv1beta1.ClusterTrustBundleList), b.(*certificates.ClusterTrustBundleList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.ClusterTrustBundleList)(nil), (*certificatesv1beta1.ClusterTrustBundleList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_ClusterTrustBundleList_To_v1beta1_ClusterTrustBundleList(a.(*certificates.ClusterTrustBundleList), b.(*certificatesv1beta1.ClusterTrustBundleList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificatesv1beta1.ClusterTrustBundleSpec)(nil), (*certificates.ClusterTrustBundleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(a.(*certificatesv1beta1.ClusterTrustBundleSpec), b.(*certificates.ClusterTrustBundleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*certificates.ClusterTrustBundleSpec)(nil), (*certificatesv1beta1.ClusterTrustBundleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_certificates_ClusterTrustBundleSpec_To_v1beta1_ClusterTrustBundleSpec(a.(*certificates.ClusterTrustBundleSpec), b.(*certificatesv1beta1.ClusterTrustBundleSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(in *certificatesv1beta1.CertificateSigningRequest, out *certificates.CertificateSigningRequest, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_CertificateSigningRequest_To_certificates_CertificateSigningRequest is an autogenerated conversion function.
func Convert_v1beta1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(in *certificatesv1beta1.CertificateSigningRequest, out *certificates.CertificateSigningRequest, s conversion.Scope) error {
        return autoConvert_v1beta1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequest_To_v1beta1_CertificateSigningRequest(in *certificates.CertificateSigningRequest, out *certificatesv1beta1.CertificateSigningRequest, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_certificates_CertificateSigningRequestSpec_To_v1beta1_CertificateSigningRequestSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_certificates_CertificateSigningRequestStatus_To_v1beta1_CertificateSigningRequestStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_certificates_CertificateSigningRequest_To_v1beta1_CertificateSigningRequest is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequest_To_v1beta1_CertificateSigningRequest(in *certificates.CertificateSigningRequest, out *certificatesv1beta1.CertificateSigningRequest, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequest_To_v1beta1_CertificateSigningRequest(in, out, s)
}

func autoConvert_v1beta1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition(in *certificatesv1beta1.CertificateSigningRequestCondition, out *certificates.CertificateSigningRequestCondition, s conversion.Scope) error {
        out.Type = certificates.RequestConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.Reason = in.Reason
        out.Message = in.Message
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        return nil
}

// Convert_v1beta1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition is an autogenerated conversion function.
func Convert_v1beta1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition(in *certificatesv1beta1.CertificateSigningRequestCondition, out *certificates.CertificateSigningRequestCondition, s conversion.Scope) error {
        return autoConvert_v1beta1_CertificateSigningRequestCondition_To_certificates_CertificateSigningRequestCondition(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequestCondition_To_v1beta1_CertificateSigningRequestCondition(in *certificates.CertificateSigningRequestCondition, out *certificatesv1beta1.CertificateSigningRequestCondition, s conversion.Scope) error {
        out.Type = certificatesv1beta1.RequestConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.Reason = in.Reason
        out.Message = in.Message
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        return nil
}

// Convert_certificates_CertificateSigningRequestCondition_To_v1beta1_CertificateSigningRequestCondition is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequestCondition_To_v1beta1_CertificateSigningRequestCondition(in *certificates.CertificateSigningRequestCondition, out *certificatesv1beta1.CertificateSigningRequestCondition, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequestCondition_To_v1beta1_CertificateSigningRequestCondition(in, out, s)
}

func autoConvert_v1beta1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList(in *certificatesv1beta1.CertificateSigningRequestList, out *certificates.CertificateSigningRequestList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]certificates.CertificateSigningRequest, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_CertificateSigningRequest_To_certificates_CertificateSigningRequest(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList is an autogenerated conversion function.
func Convert_v1beta1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList(in *certificatesv1beta1.CertificateSigningRequestList, out *certificates.CertificateSigningRequestList, s conversion.Scope) error {
        return autoConvert_v1beta1_CertificateSigningRequestList_To_certificates_CertificateSigningRequestList(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequestList_To_v1beta1_CertificateSigningRequestList(in *certificates.CertificateSigningRequestList, out *certificatesv1beta1.CertificateSigningRequestList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]certificatesv1beta1.CertificateSigningRequest, len(*in))
                for i := range *in {
                        if err := Convert_certificates_CertificateSigningRequest_To_v1beta1_CertificateSigningRequest(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_certificates_CertificateSigningRequestList_To_v1beta1_CertificateSigningRequestList is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequestList_To_v1beta1_CertificateSigningRequestList(in *certificates.CertificateSigningRequestList, out *certificatesv1beta1.CertificateSigningRequestList, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequestList_To_v1beta1_CertificateSigningRequestList(in, out, s)
}

func autoConvert_v1beta1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(in *certificatesv1beta1.CertificateSigningRequestSpec, out *certificates.CertificateSigningRequestSpec, s conversion.Scope) error {
        out.Request = *(*[]byte)(unsafe.Pointer(&in.Request))
        if err := metav1.Convert_Pointer_string_To_string(&in.SignerName, &out.SignerName, s); err != nil {
                return err
        }
        out.ExpirationSeconds = (*int32)(unsafe.Pointer(in.ExpirationSeconds))
        out.Usages = *(*[]certificates.KeyUsage)(unsafe.Pointer(&in.Usages))
        out.Username = in.Username
        out.UID = in.UID
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]certificates.ExtraValue)(unsafe.Pointer(&in.Extra))
        return nil
}

// Convert_v1beta1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec is an autogenerated conversion function.
func Convert_v1beta1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(in *certificatesv1beta1.CertificateSigningRequestSpec, out *certificates.CertificateSigningRequestSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_CertificateSigningRequestSpec_To_certificates_CertificateSigningRequestSpec(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequestSpec_To_v1beta1_CertificateSigningRequestSpec(in *certificates.CertificateSigningRequestSpec, out *certificatesv1beta1.CertificateSigningRequestSpec, s conversion.Scope) error {
        out.Request = *(*[]byte)(unsafe.Pointer(&in.Request))
        if err := metav1.Convert_string_To_Pointer_string(&in.SignerName, &out.SignerName, s); err != nil {
                return err
        }
        out.ExpirationSeconds = (*int32)(unsafe.Pointer(in.ExpirationSeconds))
        out.Usages = *(*[]certificatesv1beta1.KeyUsage)(unsafe.Pointer(&in.Usages))
        out.Username = in.Username
        out.UID = in.UID
        out.Groups = *(*[]string)(unsafe.Pointer(&in.Groups))
        out.Extra = *(*map[string]certificatesv1beta1.ExtraValue)(unsafe.Pointer(&in.Extra))
        return nil
}

// Convert_certificates_CertificateSigningRequestSpec_To_v1beta1_CertificateSigningRequestSpec is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequestSpec_To_v1beta1_CertificateSigningRequestSpec(in *certificates.CertificateSigningRequestSpec, out *certificatesv1beta1.CertificateSigningRequestSpec, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequestSpec_To_v1beta1_CertificateSigningRequestSpec(in, out, s)
}

func autoConvert_v1beta1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(in *certificatesv1beta1.CertificateSigningRequestStatus, out *certificates.CertificateSigningRequestStatus, s conversion.Scope) error {
        out.Conditions = *(*[]certificates.CertificateSigningRequestCondition)(unsafe.Pointer(&in.Conditions))
        out.Certificate = *(*[]byte)(unsafe.Pointer(&in.Certificate))
        return nil
}

// Convert_v1beta1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus is an autogenerated conversion function.
func Convert_v1beta1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(in *certificatesv1beta1.CertificateSigningRequestStatus, out *certificates.CertificateSigningRequestStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_CertificateSigningRequestStatus_To_certificates_CertificateSigningRequestStatus(in, out, s)
}

func autoConvert_certificates_CertificateSigningRequestStatus_To_v1beta1_CertificateSigningRequestStatus(in *certificates.CertificateSigningRequestStatus, out *certificatesv1beta1.CertificateSigningRequestStatus, s conversion.Scope) error {
        out.Conditions = *(*[]certificatesv1beta1.CertificateSigningRequestCondition)(unsafe.Pointer(&in.Conditions))
        out.Certificate = *(*[]byte)(unsafe.Pointer(&in.Certificate))
        return nil
}

// Convert_certificates_CertificateSigningRequestStatus_To_v1beta1_CertificateSigningRequestStatus is an autogenerated conversion function.
func Convert_certificates_CertificateSigningRequestStatus_To_v1beta1_CertificateSigningRequestStatus(in *certificates.CertificateSigningRequestStatus, out *certificatesv1beta1.CertificateSigningRequestStatus, s conversion.Scope) error {
        return autoConvert_certificates_CertificateSigningRequestStatus_To_v1beta1_CertificateSigningRequestStatus(in, out, s)
}

func autoConvert_v1beta1_ClusterTrustBundle_To_certificates_ClusterTrustBundle(in *certificatesv1beta1.ClusterTrustBundle, out *certificates.ClusterTrustBundle, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_ClusterTrustBundle_To_certificates_ClusterTrustBundle is an autogenerated conversion function.
func Convert_v1beta1_ClusterTrustBundle_To_certificates_ClusterTrustBundle(in *certificatesv1beta1.ClusterTrustBundle, out *certificates.ClusterTrustBundle, s conversion.Scope) error {
        return autoConvert_v1beta1_ClusterTrustBundle_To_certificates_ClusterTrustBundle(in, out, s)
}

func autoConvert_certificates_ClusterTrustBundle_To_v1beta1_ClusterTrustBundle(in *certificates.ClusterTrustBundle, out *certificatesv1beta1.ClusterTrustBundle, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_certificates_ClusterTrustBundleSpec_To_v1beta1_ClusterTrustBundleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_certificates_ClusterTrustBundle_To_v1beta1_ClusterTrustBundle is an autogenerated conversion function.
func Convert_certificates_ClusterTrustBundle_To_v1beta1_ClusterTrustBundle(in *certificates.ClusterTrustBundle, out *certificatesv1beta1.ClusterTrustBundle, s conversion.Scope) error {
        return autoConvert_certificates_ClusterTrustBundle_To_v1beta1_ClusterTrustBundle(in, out, s)
}

func autoConvert_v1beta1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList(in *certificatesv1beta1.ClusterTrustBundleList, out *certificates.ClusterTrustBundleList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]certificates.ClusterTrustBundle)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1beta1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList is an autogenerated conversion function.
func Convert_v1beta1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList(in *certificatesv1beta1.ClusterTrustBundleList, out *certificates.ClusterTrustBundleList, s conversion.Scope) error {
        return autoConvert_v1beta1_ClusterTrustBundleList_To_certificates_ClusterTrustBundleList(in, out, s)
}

func autoConvert_certificates_ClusterTrustBundleList_To_v1beta1_ClusterTrustBundleList(in *certificates.ClusterTrustBundleList, out *certificatesv1beta1.ClusterTrustBundleList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]certificatesv1beta1.ClusterTrustBundle)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_certificates_ClusterTrustBundleList_To_v1beta1_ClusterTrustBundleList is an autogenerated conversion function.
func Convert_certificates_ClusterTrustBundleList_To_v1beta1_ClusterTrustBundleList(in *certificates.ClusterTrustBundleList, out *certificatesv1beta1.ClusterTrustBundleList, s conversion.Scope) error {
        return autoConvert_certificates_ClusterTrustBundleList_To_v1beta1_ClusterTrustBundleList(in, out, s)
}

func autoConvert_v1beta1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(in *certificatesv1beta1.ClusterTrustBundleSpec, out *certificates.ClusterTrustBundleSpec, s conversion.Scope) error {
        out.SignerName = in.SignerName
        out.TrustBundle = in.TrustBundle
        return nil
}

// Convert_v1beta1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec is an autogenerated conversion function.
func Convert_v1beta1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(in *certificatesv1beta1.ClusterTrustBundleSpec, out *certificates.ClusterTrustBundleSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_ClusterTrustBundleSpec_To_certificates_ClusterTrustBundleSpec(in, out, s)
}

func autoConvert_certificates_ClusterTrustBundleSpec_To_v1beta1_ClusterTrustBundleSpec(in *certificates.ClusterTrustBundleSpec, out *certificatesv1beta1.ClusterTrustBundleSpec, s conversion.Scope) error {
        out.SignerName = in.SignerName
        out.TrustBundle = in.TrustBundle
        return nil
}

// Convert_certificates_ClusterTrustBundleSpec_To_v1beta1_ClusterTrustBundleSpec is an autogenerated conversion function.
func Convert_certificates_ClusterTrustBundleSpec_To_v1beta1_ClusterTrustBundleSpec(in *certificates.ClusterTrustBundleSpec, out *certificatesv1beta1.ClusterTrustBundleSpec, s conversion.Scope) error {
        return autoConvert_certificates_ClusterTrustBundleSpec_To_v1beta1_ClusterTrustBundleSpec(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        certificatesv1beta1 "k8s.io/api/certificates/v1beta1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&certificatesv1beta1.CertificateSigningRequest{}, func(obj interface{}) {
                SetObjectDefaults_CertificateSigningRequest(obj.(*certificatesv1beta1.CertificateSigningRequest))
        })
        scheme.AddTypeDefaultingFunc(&certificatesv1beta1.CertificateSigningRequestList{}, func(obj interface{}) {
                SetObjectDefaults_CertificateSigningRequestList(obj.(*certificatesv1beta1.CertificateSigningRequestList))
        })
        return nil
}

func SetObjectDefaults_CertificateSigningRequest(in *certificatesv1beta1.CertificateSigningRequest) {
        SetDefaults_CertificateSigningRequestSpec(&in.Spec)
        for i := range in.Status.Conditions {
                a := &in.Status.Conditions[i]
                SetDefaults_CertificateSigningRequestCondition(a)
        }
}

func SetObjectDefaults_CertificateSigningRequestList(in *certificatesv1beta1.CertificateSigningRequestList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_CertificateSigningRequest(a)
        }
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 validation-gen. DO NOT EDIT.

package v1beta1

import (
        context "context"
        fmt "fmt"

        certificatesv1beta1 "k8s.io/api/certificates/v1beta1"
        equality "k8s.io/apimachinery/pkg/api/equality"
        operation "k8s.io/apimachinery/pkg/api/operation"
        safe "k8s.io/apimachinery/pkg/api/safe"
        validate "k8s.io/apimachinery/pkg/api/validate"
        runtime "k8s.io/apimachinery/pkg/runtime"
        field "k8s.io/apimachinery/pkg/util/validation/field"
)

func init() { localSchemeBuilder.Register(RegisterValidations) }

// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
        scheme.AddValidationFunc((*certificatesv1beta1.CertificateSigningRequest)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/", "/approval", "/status":
                        return Validate_CertificateSigningRequest(ctx, op, nil /* fldPath */, obj.(*certificatesv1beta1.CertificateSigningRequest), safe.Cast[*certificatesv1beta1.CertificateSigningRequest](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        scheme.AddValidationFunc((*certificatesv1beta1.CertificateSigningRequestList)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/":
                        return Validate_CertificateSigningRequestList(ctx, op, nil /* fldPath */, obj.(*certificatesv1beta1.CertificateSigningRequestList), safe.Cast[*certificatesv1beta1.CertificateSigningRequestList](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        return nil
}

func Validate_CertificateSigningRequest(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *certificatesv1beta1.CertificateSigningRequest) (errs field.ErrorList) {
        // field certificatesv1beta1.CertificateSigningRequest.TypeMeta has no validation
        // field certificatesv1beta1.CertificateSigningRequest.ObjectMeta has no validation
        // field certificatesv1beta1.CertificateSigningRequest.Spec has no validation

        // field certificatesv1beta1.CertificateSigningRequest.Status
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *certificatesv1beta1.CertificateSigningRequestStatus) (errs field.ErrorList) {
                        errs = append(errs, Validate_CertificateSigningRequestStatus(ctx, op, fldPath, obj, oldObj)...)
                        return
                }(fldPath.Child("status"), &obj.Status, safe.Field(oldObj, func(oldObj *certificatesv1beta1.CertificateSigningRequest) *certificatesv1beta1.CertificateSigningRequestStatus {
                        return &oldObj.Status
                }))...)

        return errs
}

func Validate_CertificateSigningRequestList(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *certificatesv1beta1.CertificateSigningRequestList) (errs field.ErrorList) {
        // field certificatesv1beta1.CertificateSigningRequestList.TypeMeta has no validation
        // field certificatesv1beta1.CertificateSigningRequestList.ListMeta has no validation

        // field certificatesv1beta1.CertificateSigningRequestList.Items
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj []certificatesv1beta1.CertificateSigningRequest) (errs field.ErrorList) {
                        if op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
                                return nil // no changes
                        }
                        errs = append(errs, validate.EachSliceVal(ctx, op, fldPath, obj, oldObj, nil, nil, Validate_CertificateSigningRequest)...)
                        return
                }(fldPath.Child("items"), obj.Items, safe.Field(oldObj, func(oldObj *certificatesv1beta1.CertificateSigningRequestList) []certificatesv1beta1.CertificateSigningRequest {
                        return oldObj.Items
                }))...)

        return errs
}

var zeroOrOneOfMembershipFor_k8s_io_api_certificates_v1beta1_CertificateSigningRequestStatus_Conditions_ = validate.NewUnionMembership([2]string{"Conditions[{\"type\": \"Approved\"}]", ""}, [2]string{"Conditions[{\"type\": \"Denied\"}]", ""})

func Validate_CertificateSigningRequestStatus(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *certificatesv1beta1.CertificateSigningRequestStatus) (errs field.ErrorList) {
        // field certificatesv1beta1.CertificateSigningRequestStatus.Conditions
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj []certificatesv1beta1.CertificateSigningRequestCondition) (errs field.ErrorList) {
                        if op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
                                return nil // no changes
                        }
                        if e := validate.OptionalSlice(ctx, op, fldPath, obj, oldObj); len(e) != 0 {
                                return // do not proceed
                        }
                        errs = append(errs, validate.ZeroOrOneOfUnion(ctx, op, fldPath, obj, oldObj, zeroOrOneOfMembershipFor_k8s_io_api_certificates_v1beta1_CertificateSigningRequestStatus_Conditions_, func(list []certificatesv1beta1.CertificateSigningRequestCondition) bool {
                                for i := range list {
                                        if list[i].Type == "Approved" {
                                                return true
                                        }
                                }
                                return false
                        }, func(list []certificatesv1beta1.CertificateSigningRequestCondition) bool {
                                for i := range list {
                                        if list[i].Type == "Denied" {
                                                return true
                                        }
                                }
                                return false
                        })...)
                        return
                }(fldPath.Child("conditions"), obj.Conditions, safe.Field(oldObj, func(oldObj *certificatesv1beta1.CertificateSigningRequestStatus) []certificatesv1beta1.CertificateSigningRequestCondition {
                        return oldObj.Conditions
                }))...)

        // field certificatesv1beta1.CertificateSigningRequestStatus.Certificate has no validation
        return errs
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package validation

import (
        "bytes"
        "crypto"
        "crypto/ecdsa"
        "crypto/ed25519"
        "crypto/elliptic"
        "crypto/rsa"
        "crypto/sha256"
        "crypto/x509"
        "encoding/pem"
        "fmt"
        "strconv"
        "time"

        v1 "k8s.io/api/core/v1"
        apiequality "k8s.io/apimachinery/pkg/api/equality"
        apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        metav1validation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
        "k8s.io/apimachinery/pkg/util/diff"
        "k8s.io/apimachinery/pkg/util/sets"
        "k8s.io/apimachinery/pkg/util/validation/field"
        utilcert "k8s.io/client-go/util/cert"
        "k8s.io/kubernetes/pkg/apis/certificates"
        apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
        "k8s.io/utils/clock"
)

var (
        // trueConditionTypes is the set of condition types which may only have a status of True if present
        trueConditionTypes = sets.NewString(
                string(certificates.CertificateApproved),
                string(certificates.CertificateDenied),
                string(certificates.CertificateFailed),
        )

        trueStatusOnly  = sets.NewString(string(v1.ConditionTrue))
        allStatusValues = sets.NewString(string(v1.ConditionTrue), string(v1.ConditionFalse), string(v1.ConditionUnknown))
)

type certificateValidationOptions struct {
        // The following allow modifications only permitted via certain update paths

        // allow populating/modifying Approved/Denied conditions
        allowSettingApprovalConditions bool
        // allow populating status.certificate
        allowSettingCertificate bool

        // allow Approved and Denied conditions to be exist.
        // we tolerate this when the problem is already present in the persisted object for compatibility.
        allowBothApprovedAndDenied bool

        // The following are bad things we tolerate for compatibility reasons:
        // * in requests made via the v1beta1 API
        // * in update requests where the problem is already present in the persisted object

        // allow modifying status.certificate on an update where the old object has a different certificate
        allowResettingCertificate bool
        // allow the legacy-unknown signerName
        allowLegacySignerName bool
        // allow conditions with duplicate types
        allowDuplicateConditionTypes bool
        // allow conditions with "" types
        allowEmptyConditionType bool
        // allow arbitrary content in status.certificate
        allowArbitraryCertificate bool
        // allow usages values outside the known set
        allowUnknownUsages bool
        // allow duplicate usages values
        allowDuplicateUsages bool
}

// validateCSR validates the signature and formatting of a base64-wrapped,
// PEM-encoded PKCS#10 certificate signing request. If this is invalid, we must
// not accept the CSR for further processing.
func validateCSR(obj *certificates.CertificateSigningRequest) error {
        csr, err := certificates.ParseCSR(obj.Spec.Request)
        if err != nil {
                return err
        }
        // check that the signature is valid
        return csr.CheckSignature()
}

func validateCertificate(pemData []byte) error {
        if len(pemData) == 0 {
                return nil
        }

        blocks := 0
        for {
                block, remainingData := pem.Decode(pemData)
                if block == nil {
                        break
                }

                if block.Type != utilcert.CertificateBlockType {
                        return fmt.Errorf("only CERTIFICATE PEM blocks are allowed, found %q", block.Type)
                }
                if len(block.Headers) != 0 {
                        return fmt.Errorf("no PEM block headers are permitted")
                }
                blocks++

                certs, err := x509.ParseCertificates(block.Bytes)
                if err != nil {
                        return err
                }
                if len(certs) == 0 {
                        return fmt.Errorf("found CERTIFICATE PEM block containing 0 certificates")
                }

                pemData = remainingData
        }

        if blocks == 0 {
                return fmt.Errorf("must contain at least one CERTIFICATE PEM block")
        }

        return nil
}

// We don't care what you call your certificate requests.
func ValidateCertificateRequestName(name string, prefix bool) []string {
        return nil
}

func ValidateCertificateSigningRequestCreate(csr *certificates.CertificateSigningRequest) field.ErrorList {
        opts := getValidationOptions(csr, nil)
        return validateCertificateSigningRequest(csr, opts)
}

var (
        allValidUsages = sets.NewString(
                string(certificates.UsageSigning),
                string(certificates.UsageDigitalSignature),
                string(certificates.UsageContentCommitment),
                string(certificates.UsageKeyEncipherment),
                string(certificates.UsageKeyAgreement),
                string(certificates.UsageDataEncipherment),
                string(certificates.UsageCertSign),
                string(certificates.UsageCRLSign),
                string(certificates.UsageEncipherOnly),
                string(certificates.UsageDecipherOnly),
                string(certificates.UsageAny),
                string(certificates.UsageServerAuth),
                string(certificates.UsageClientAuth),
                string(certificates.UsageCodeSigning),
                string(certificates.UsageEmailProtection),
                string(certificates.UsageSMIME),
                string(certificates.UsageIPsecEndSystem),
                string(certificates.UsageIPsecTunnel),
                string(certificates.UsageIPsecUser),
                string(certificates.UsageTimestamping),
                string(certificates.UsageOCSPSigning),
                string(certificates.UsageMicrosoftSGC),
                string(certificates.UsageNetscapeSGC),
        )
)

func validateCertificateSigningRequest(csr *certificates.CertificateSigningRequest, opts certificateValidationOptions) field.ErrorList {
        isNamespaced := false
        allErrs := apivalidation.ValidateObjectMeta(&csr.ObjectMeta, isNamespaced, ValidateCertificateRequestName, field.NewPath("metadata"))

        specPath := field.NewPath("spec")
        err := validateCSR(csr)
        if err != nil {
                allErrs = append(allErrs, field.Invalid(specPath.Child("request"), csr.Spec.Request, fmt.Sprintf("%v", err)))
        }
        if len(csr.Spec.Usages) == 0 {
                allErrs = append(allErrs, field.Required(specPath.Child("usages"), ""))
        }
        if !opts.allowUnknownUsages {
                for i, usage := range csr.Spec.Usages {
                        if !allValidUsages.Has(string(usage)) {
                                allErrs = append(allErrs, field.NotSupported(specPath.Child("usages").Index(i), usage, allValidUsages.List()))
                        }
                }
        }
        if !opts.allowDuplicateUsages {
                seen := make(map[certificates.KeyUsage]bool, len(csr.Spec.Usages))
                for i, usage := range csr.Spec.Usages {
                        if seen[usage] {
                                allErrs = append(allErrs, field.Duplicate(specPath.Child("usages").Index(i), usage))
                        }
                        seen[usage] = true
                }
        }
        if !opts.allowLegacySignerName && csr.Spec.SignerName == certificates.LegacyUnknownSignerName {
                allErrs = append(allErrs, field.Invalid(specPath.Child("signerName"), csr.Spec.SignerName, "the legacy signerName is not allowed via this API version"))
        } else {
                allErrs = append(allErrs, apivalidation.ValidateSignerName(specPath.Child("signerName"), csr.Spec.SignerName)...)
        }
        if csr.Spec.ExpirationSeconds != nil && *csr.Spec.ExpirationSeconds < 600 {
                allErrs = append(allErrs, field.Invalid(specPath.Child("expirationSeconds"), *csr.Spec.ExpirationSeconds, "may not specify a duration less than 600 seconds (10 minutes)"))
        }
        allErrs = append(allErrs, validateConditions(field.NewPath("status", "conditions"), csr, opts)...)

        if !opts.allowArbitraryCertificate {
                if err := validateCertificate(csr.Status.Certificate); err != nil {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("status", "certificate"), "<certificate data>", err.Error()))
                }
        }

        return allErrs
}

func validateConditions(fldPath *field.Path, csr *certificates.CertificateSigningRequest, opts certificateValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        seenTypes := map[certificates.RequestConditionType]bool{}
        hasApproved := false
        hasDenied := false

        for i, c := range csr.Status.Conditions {

                if !opts.allowEmptyConditionType {
                        if len(c.Type) == 0 {
                                allErrs = append(allErrs, field.Required(fldPath.Index(i).Child("type"), ""))
                        }
                }

                allowedStatusValues := allStatusValues
                if trueConditionTypes.Has(string(c.Type)) {
                        allowedStatusValues = trueStatusOnly
                }
                switch {
                case c.Status == "":
                        allErrs = append(allErrs, field.Required(fldPath.Index(i).Child("status"), ""))
                case !allowedStatusValues.Has(string(c.Status)):
                        allErrs = append(allErrs, field.NotSupported(fldPath.Index(i).Child("status"), c.Status, allowedStatusValues.List()))
                }

                if !opts.allowBothApprovedAndDenied {
                        switch c.Type {
                        case certificates.CertificateApproved:
                                hasApproved = true
                                if hasDenied {
                                        allErrs = append(allErrs, field.Invalid(fldPath, c.Type, "Approved and Denied conditions are mutually exclusive").WithOrigin("zeroOrOneOf").MarkCoveredByDeclarative())
                                }
                        case certificates.CertificateDenied:
                                hasDenied = true
                                if hasApproved {
                                        allErrs = append(allErrs, field.Invalid(fldPath, c.Type, "Approved and Denied conditions are mutually exclusive").WithOrigin("zeroOrOneOf").MarkCoveredByDeclarative())
                                }
                        }
                }

                if !opts.allowDuplicateConditionTypes {
                        if seenTypes[c.Type] {
                                allErrs = append(allErrs, field.Duplicate(fldPath.Index(i).Child("type"), c.Type))
                        }
                        seenTypes[c.Type] = true
                }
        }

        return allErrs
}

func ValidateCertificateSigningRequestUpdate(newCSR, oldCSR *certificates.CertificateSigningRequest) field.ErrorList {
        opts := getValidationOptions(newCSR, oldCSR)
        return validateCertificateSigningRequestUpdate(newCSR, oldCSR, opts)
}

func ValidateCertificateSigningRequestStatusUpdate(newCSR, oldCSR *certificates.CertificateSigningRequest) field.ErrorList {
        opts := getValidationOptions(newCSR, oldCSR)
        opts.allowSettingCertificate = true
        return validateCertificateSigningRequestUpdate(newCSR, oldCSR, opts)
}

func ValidateCertificateSigningRequestApprovalUpdate(newCSR, oldCSR *certificates.CertificateSigningRequest) field.ErrorList {
        opts := getValidationOptions(newCSR, oldCSR)
        opts.allowSettingApprovalConditions = true
        return validateCertificateSigningRequestUpdate(newCSR, oldCSR, opts)
}

func validateCertificateSigningRequestUpdate(newCSR, oldCSR *certificates.CertificateSigningRequest, opts certificateValidationOptions) field.ErrorList {
        validationErrorList := validateCertificateSigningRequest(newCSR, opts)
        metaUpdateErrorList := apivalidation.ValidateObjectMetaUpdate(&newCSR.ObjectMeta, &oldCSR.ObjectMeta, field.NewPath("metadata"))

        // prevent removal of existing Approved/Denied/Failed conditions
        for _, t := range []certificates.RequestConditionType{certificates.CertificateApproved, certificates.CertificateDenied, certificates.CertificateFailed} {
                oldConditions := findConditions(oldCSR, t)
                newConditions := findConditions(newCSR, t)
                if len(newConditions) < len(oldConditions) {
                        validationErrorList = append(validationErrorList, field.Forbidden(field.NewPath("status", "conditions"), fmt.Sprintf("updates may not remove a condition of type %q", t)))
                }
        }

        if !opts.allowSettingApprovalConditions {
                // prevent addition/removal/modification of Approved/Denied conditions
                for _, t := range []certificates.RequestConditionType{certificates.CertificateApproved, certificates.CertificateDenied} {
                        oldConditions := findConditions(oldCSR, t)
                        newConditions := findConditions(newCSR, t)
                        switch {
                        case len(newConditions) < len(oldConditions):
                                // removals are prevented above
                        case len(newConditions) > len(oldConditions):
                                validationErrorList = append(validationErrorList, field.Forbidden(field.NewPath("status", "conditions"), fmt.Sprintf("updates may not add a condition of type %q", t)))
                        case !apiequality.Semantic.DeepEqual(oldConditions, newConditions):
                                conditionDiff := diff.Diff(oldConditions, newConditions)
                                validationErrorList = append(validationErrorList, field.Forbidden(field.NewPath("status", "conditions"), fmt.Sprintf("updates may not modify a condition of type %q\n%v", t, conditionDiff)))
                        }
                }
        }

        if !bytes.Equal(newCSR.Status.Certificate, oldCSR.Status.Certificate) {
                if !opts.allowSettingCertificate {
                        validationErrorList = append(validationErrorList, field.Forbidden(field.NewPath("status", "certificate"), "updates may not set certificate content"))
                } else if !opts.allowResettingCertificate && len(oldCSR.Status.Certificate) > 0 {
                        validationErrorList = append(validationErrorList, field.Forbidden(field.NewPath("status", "certificate"), "updates may not modify existing certificate content"))
                }
        }

        return append(validationErrorList, metaUpdateErrorList...)
}

// findConditions returns all instances of conditions of the specified type
func findConditions(csr *certificates.CertificateSigningRequest, conditionType certificates.RequestConditionType) []certificates.CertificateSigningRequestCondition {
        var retval []certificates.CertificateSigningRequestCondition
        for i, c := range csr.Status.Conditions {
                if c.Type == conditionType {
                        retval = append(retval, csr.Status.Conditions[i])
                }
        }
        return retval
}

// getValidationOptions returns the validation options to be
// compatible with the specified version and existing CSR.
// oldCSR may be nil if this is a create request.
// validation options related to subresource-specific capabilities are set to false.
func getValidationOptions(newCSR, oldCSR *certificates.CertificateSigningRequest) certificateValidationOptions {
        return certificateValidationOptions{
                allowResettingCertificate:    false,
                allowBothApprovedAndDenied:   allowBothApprovedAndDenied(oldCSR),
                allowLegacySignerName:        allowLegacySignerName(oldCSR),
                allowDuplicateConditionTypes: allowDuplicateConditionTypes(oldCSR),
                allowEmptyConditionType:      allowEmptyConditionType(oldCSR),
                allowArbitraryCertificate:    allowArbitraryCertificate(newCSR, oldCSR),
                allowDuplicateUsages:         allowDuplicateUsages(oldCSR),
                allowUnknownUsages:           allowUnknownUsages(oldCSR),
        }
}

func allowBothApprovedAndDenied(oldCSR *certificates.CertificateSigningRequest) bool {
        if oldCSR == nil {
                return false
        }
        approved := false
        denied := false
        for _, c := range oldCSR.Status.Conditions {
                if c.Type == certificates.CertificateApproved {
                        approved = true
                } else if c.Type == certificates.CertificateDenied {
                        denied = true
                }
        }
        // compatibility with existing data
        return approved && denied
}

func allowLegacySignerName(oldCSR *certificates.CertificateSigningRequest) bool {
        switch {
        case oldCSR != nil && oldCSR.Spec.SignerName == certificates.LegacyUnknownSignerName:
                return true // compatibility with existing data
        default:
                return false
        }
}

func allowDuplicateConditionTypes(oldCSR *certificates.CertificateSigningRequest) bool {
        switch {
        case oldCSR != nil && hasDuplicateConditionTypes(oldCSR):
                return true // compatibility with existing data
        default:
                return false
        }
}
func hasDuplicateConditionTypes(csr *certificates.CertificateSigningRequest) bool {
        seen := map[certificates.RequestConditionType]bool{}
        for _, c := range csr.Status.Conditions {
                if seen[c.Type] {
                        return true
                }
                seen[c.Type] = true
        }
        return false
}

func allowEmptyConditionType(oldCSR *certificates.CertificateSigningRequest) bool {
        switch {
        case oldCSR != nil && hasEmptyConditionType(oldCSR):
                return true // compatibility with existing data
        default:
                return false
        }
}
func hasEmptyConditionType(csr *certificates.CertificateSigningRequest) bool {
        for _, c := range csr.Status.Conditions {
                if len(c.Type) == 0 {
                        return true
                }
        }
        return false
}

func allowArbitraryCertificate(newCSR, oldCSR *certificates.CertificateSigningRequest) bool {
        switch {
        case newCSR != nil && oldCSR != nil && bytes.Equal(newCSR.Status.Certificate, oldCSR.Status.Certificate):
                return true // tolerate updates that don't touch status.certificate
        case oldCSR != nil && validateCertificate(oldCSR.Status.Certificate) != nil:
                return true // compatibility with existing data
        default:
                return false
        }
}

func allowUnknownUsages(oldCSR *certificates.CertificateSigningRequest) bool {
        switch {
        case oldCSR != nil && hasUnknownUsage(oldCSR.Spec.Usages):
                return true // compatibility with existing data
        default:
                return false
        }
}

func hasUnknownUsage(usages []certificates.KeyUsage) bool {
        for _, usage := range usages {
                if !allValidUsages.Has(string(usage)) {
                        return true
                }
        }
        return false
}

func allowDuplicateUsages(oldCSR *certificates.CertificateSigningRequest) bool {
        switch {
        case oldCSR != nil && hasDuplicateUsage(oldCSR.Spec.Usages):
                return true // compatibility with existing data
        default:
                return false
        }
}

func hasDuplicateUsage(usages []certificates.KeyUsage) bool {
        seen := make(map[certificates.KeyUsage]bool, len(usages))
        for _, usage := range usages {
                if seen[usage] {
                        return true
                }
                seen[usage] = true
        }
        return false
}

type ValidateClusterTrustBundleOptions struct {
        SuppressBundleParsing bool
}

// ValidateClusterTrustBundle runs all validation checks on bundle.
func ValidateClusterTrustBundle(bundle *certificates.ClusterTrustBundle, opts ValidateClusterTrustBundleOptions) field.ErrorList {
        var allErrors field.ErrorList

        metaErrors := apivalidation.ValidateObjectMeta(&bundle.ObjectMeta, false, apivalidation.ValidateClusterTrustBundleName(bundle.Spec.SignerName), field.NewPath("metadata"))
        allErrors = append(allErrors, metaErrors...)

        if bundle.Spec.SignerName != "" {
                signerNameErrors := apivalidation.ValidateSignerName(field.NewPath("spec", "signerName"), bundle.Spec.SignerName)
                allErrors = append(allErrors, signerNameErrors...)
        }

        if !opts.SuppressBundleParsing {
                pemErrors := validateTrustBundle(field.NewPath("spec", "trustBundle"), bundle.Spec.TrustBundle)
                allErrors = append(allErrors, pemErrors...)
        }

        return allErrors
}

// ValidateClusterTrustBundleUpdate runs all update validation checks on an
// update.
func ValidateClusterTrustBundleUpdate(newBundle, oldBundle *certificates.ClusterTrustBundle) field.ErrorList {
        // If the caller isn't changing the TrustBundle field, don't parse it.
        // This helps smoothly handle changes in Go's PEM or X.509 parsing
        // libraries.
        opts := ValidateClusterTrustBundleOptions{}
        if newBundle.Spec.TrustBundle == oldBundle.Spec.TrustBundle {
                opts.SuppressBundleParsing = true
        }

        var allErrors field.ErrorList
        allErrors = append(allErrors, ValidateClusterTrustBundle(newBundle, opts)...)
        allErrors = append(allErrors, apivalidation.ValidateObjectMetaUpdate(&newBundle.ObjectMeta, &oldBundle.ObjectMeta, field.NewPath("metadata"))...)
        allErrors = append(allErrors, apivalidation.ValidateImmutableField(newBundle.Spec.SignerName, oldBundle.Spec.SignerName, field.NewPath("spec", "signerName"))...)
        return allErrors
}

// validateTrustBundle rejects intra-block headers, blocks
// that don't parse as X.509 CA certificates, and duplicate trust anchors.  It
// requires that at least one trust anchor is provided.
func validateTrustBundle(path *field.Path, in string) field.ErrorList {
        var allErrors field.ErrorList

        if len(in) > certificates.MaxTrustBundleSize {
                allErrors = append(allErrors, field.TooLong(path, "" /*unused*/, certificates.MaxTrustBundleSize))
                return allErrors
        }

        blockDedupe := map[string][]int{}

        rest := []byte(in)
        var b *pem.Block
        i := -1
        for {
                b, rest = pem.Decode(rest)
                if b == nil {
                        break
                }
                i++

                if b.Type != "CERTIFICATE" {
                        allErrors = append(allErrors, field.Invalid(path, "<value omitted>", fmt.Sprintf("entry %d has bad block type: %v", i, b.Type)))
                        continue
                }

                if len(b.Headers) != 0 {
                        allErrors = append(allErrors, field.Invalid(path, "<value omitted>", fmt.Sprintf("entry %d has PEM block headers", i)))
                        continue
                }

                cert, err := x509.ParseCertificate(b.Bytes)
                if err != nil {
                        allErrors = append(allErrors, field.Invalid(path, "<value omitted>", fmt.Sprintf("entry %d does not parse as X.509", i)))
                        continue
                }

                if !cert.IsCA {
                        allErrors = append(allErrors, field.Invalid(path, "<value omitted>", fmt.Sprintf("entry %d does not have the CA bit set", i)))
                        continue
                }

                if !cert.BasicConstraintsValid {
                        allErrors = append(allErrors, field.Invalid(path, "<value omitted>", fmt.Sprintf("entry %d has invalid basic constraints", i)))
                        continue
                }

                blockDedupe[string(b.Bytes)] = append(blockDedupe[string(b.Bytes)], i)
        }

        // If we had a malformed block, don't also output potentially-redundant
        // errors about duplicate or missing trust anchors.
        if len(allErrors) != 0 {
                return allErrors
        }

        if len(blockDedupe) == 0 {
                allErrors = append(allErrors, field.Invalid(path, "<value omitted>", "at least one trust anchor must be provided"))
        }

        for _, indices := range blockDedupe {
                if len(indices) > 1 {
                        allErrors = append(allErrors, field.Invalid(path, "<value omitted>", fmt.Sprintf("duplicate trust anchor (indices %v)", indices)))
                }
        }

        return allErrors
}

// ValidatePodCertificateRequestCreate runs all validation checks on a pod certificate request create.
func ValidatePodCertificateRequestCreate(req *certificates.PodCertificateRequest) field.ErrorList {
        var allErrors field.ErrorList

        metaErrors := apivalidation.ValidateObjectMeta(&req.ObjectMeta, true, apimachineryvalidation.NameIsDNSSubdomain, field.NewPath("metadata"))
        allErrors = append(allErrors, metaErrors...)

        signerNameErrors := apivalidation.ValidateSignerName(field.NewPath("spec", "signerName"), req.Spec.SignerName)
        allErrors = append(allErrors, signerNameErrors...)

        for _, msg := range apivalidation.ValidatePodName(req.Spec.PodName, false) {
                allErrors = append(allErrors, field.Invalid(field.NewPath("spec", "podName"), req.Spec.PodName, msg))
        }
        if len(req.Spec.PodUID) == 0 {
                allErrors = append(allErrors, field.Invalid(field.NewPath("spec", "podUID"), req.Spec.PodUID, "must not be empty"))
        }
        if len(req.Spec.PodUID) > 128 {
                allErrors = append(allErrors, field.TooLong(field.NewPath("spec", "podUID"), req.Spec.PodUID, 128))
        }
        for _, msg := range apivalidation.ValidateServiceAccountName(req.Spec.ServiceAccountName, false) {
                allErrors = append(allErrors, field.Invalid(field.NewPath("spec", "serviceAccountName"), req.Spec.ServiceAccountName, msg))
        }
        if len(req.Spec.ServiceAccountUID) == 0 {
                allErrors = append(allErrors, field.Invalid(field.NewPath("spec", "serviceAccountUID"), req.Spec.ServiceAccountUID, "must not be empty"))
        }
        if len(req.Spec.ServiceAccountUID) > 128 {
                allErrors = append(allErrors, field.TooLong(field.NewPath("spec", "serviceAccountUID"), req.Spec.ServiceAccountUID, 128))
        }
        for _, msg := range apivalidation.ValidateNodeName(string(req.Spec.NodeName), false) {
                allErrors = append(allErrors, field.Invalid(field.NewPath("spec", "nodeName"), req.Spec.NodeName, msg))
        }
        if len(req.Spec.NodeUID) == 0 {
                allErrors = append(allErrors, field.Invalid(field.NewPath("spec", "nodeUID"), req.Spec.NodeUID, "must not be empty"))
        }
        if len(req.Spec.NodeUID) > 128 {
                allErrors = append(allErrors, field.TooLong(field.NewPath("spec", "nodeUID"), req.Spec.NodeUID, 128))
        }

        if req.Spec.MaxExpirationSeconds == nil {
                allErrors = append(allErrors, field.Required(field.NewPath("spec", "maxExpirationSeconds"), "must be set"))
                return allErrors
        }
        if apivalidation.IsKubernetesSignerName(req.Spec.SignerName) {
                // Kubernetes signers are restricted to max 24 hour certs
                if !(certificates.MinMaxExpirationSeconds <= *req.Spec.MaxExpirationSeconds && *req.Spec.MaxExpirationSeconds <= certificates.KubernetesMaxMaxExpirationSeconds) {
                        allErrors = append(allErrors, field.Invalid(field.NewPath("spec", "maxExpirationSeconds"), req.Spec.MaxExpirationSeconds, fmt.Sprintf("must be in the range [%d, %d]", certificates.MinMaxExpirationSeconds, certificates.KubernetesMaxMaxExpirationSeconds)))
                }
        } else {
                // All other signers are restricted to max 91 day certs.
                if !(certificates.MinMaxExpirationSeconds <= *req.Spec.MaxExpirationSeconds && *req.Spec.MaxExpirationSeconds <= certificates.MaxMaxExpirationSeconds) {
                        allErrors = append(allErrors, field.Invalid(field.NewPath("spec", "maxExpirationSeconds"), req.Spec.MaxExpirationSeconds, fmt.Sprintf("must be in the range [%d, %d]", certificates.MinMaxExpirationSeconds, certificates.MaxMaxExpirationSeconds)))
                }
        }

        if len(req.Spec.PKIXPublicKey) > certificates.MaxPKIXPublicKeySize {
                allErrors = append(allErrors, field.TooLong(field.NewPath("spec", "pkixPublicKey"), req.Spec.PKIXPublicKey, certificates.MaxPKIXPublicKeySize))
                return allErrors
        }

        if len(req.Spec.ProofOfPossession) > certificates.MaxProofOfPossessionSize {
                allErrors = append(allErrors, field.TooLong(field.NewPath("spec", "proofOfPossession"), req.Spec.ProofOfPossession, certificates.MaxProofOfPossessionSize))
                return allErrors
        }

        pubAny, err := x509.ParsePKIXPublicKey(req.Spec.PKIXPublicKey)
        if err != nil {
                allErrors = append(allErrors, field.Invalid(pkixPath, req.Spec.PKIXPublicKey, "must be a valid PKIX-serialized public key"))
                return allErrors
        }

        // Verify public key properties and the proof-of-possession signature.
        switch pub := pubAny.(type) {
        case ed25519.PublicKey:
                // ed25519 has no key configuration to check
                if !ed25519.Verify(pub, []byte(req.Spec.PodUID), req.Spec.ProofOfPossession) {
                        allErrors = append(allErrors, field.Invalid(popPath, field.OmitValueType{}, "could not verify proof-of-possession signature"))
                        return allErrors
                }

        case *ecdsa.PublicKey:
                if pub.Curve != elliptic.P256() && pub.Curve != elliptic.P384() && pub.Curve != elliptic.P521() {
                        allErrors = append(allErrors, field.Invalid(pkixPath, "curve "+pub.Curve.Params().Name, "elliptic public keys must use curve P256 or P384"))
                        return allErrors
                }
                if !ecdsa.VerifyASN1(pub, hashBytes([]byte(req.Spec.PodUID)), req.Spec.ProofOfPossession) {
                        allErrors = append(allErrors, field.Invalid(popPath, field.OmitValueType{}, "could not verify proof-of-possession signature"))
                        return allErrors
                }

        case *rsa.PublicKey:
                if pub.Size()*8 != 3072 && pub.Size()*8 != 4096 {
                        allErrors = append(allErrors, field.Invalid(pkixPath, fmt.Sprintf("%d-bit modulus", pub.Size()*8), "RSA keys must have modulus size 3072 or 4096"))
                        return allErrors
                }
                if err := rsa.VerifyPSS(pub, crypto.SHA256, hashBytes([]byte(req.Spec.PodUID)), req.Spec.ProofOfPossession, nil); err != nil {
                        allErrors = append(allErrors, field.Invalid(popPath, field.OmitValueType{}, "could not verify proof-of-possession signature"))
                        return allErrors
                }

        default:
                allErrors = append(allErrors, field.Invalid(pkixPath, req.Spec.PKIXPublicKey, "unknown public key type; supported types are Ed25519, ECDSA, and RSA"))
                return allErrors
        }

        return allErrors
}

func hashBytes(in []byte) []byte {
        out := sha256.Sum256(in)
        return out[:]
}

var (
        pkixPath         = field.NewPath("spec", "pkixPublicKey")
        popPath          = field.NewPath("spec", "proofOfPossession")
        certChainPath    = field.NewPath("status", "certificateChain")
        notBeforePath    = field.NewPath("status", "notBefore")
        notAfterPath     = field.NewPath("status", "notAfter")
        beginRefreshPath = field.NewPath("status", "beginRefreshAt")
)

// ValidatePodCertificateRequestUpdate runs all update validation checks on a
// non-status update.
//
// All spec fields are immutable after creation, and status updates must go
// through the dedicated status update verb, so only metadata updates are
// allowed.
func ValidatePodCertificateRequestUpdate(newReq, oldReq *certificates.PodCertificateRequest) field.ErrorList {
        var allErrors field.ErrorList
        allErrors = append(allErrors, apivalidation.ValidateObjectMetaUpdate(&newReq.ObjectMeta, &oldReq.ObjectMeta, field.NewPath("metadata"))...)

        // All spec fields are immutable.
        allErrors = append(allErrors, apivalidation.ValidateImmutableField(newReq.Spec, oldReq.Spec, field.NewPath("spec"))...)

        return allErrors
}

// ValidatePodCertificateRequestStatusUpdate validates a status update for a
// PodCertificateRequest.
func ValidatePodCertificateRequestStatusUpdate(newReq, oldReq *certificates.PodCertificateRequest, clock clock.PassiveClock) field.ErrorList {
        var allErrors field.ErrorList

        // Metadata is *mostly* immutable... ManagedFields is allowed to change.  We
        // are reliant on the strategy that's calling us to have patched
        // newReq.ObjectMeta using metav1.ResetObjectMetaForStatus.
        allErrors = append(allErrors, apivalidation.ValidateObjectMetaUpdate(&newReq.ObjectMeta, &oldReq.ObjectMeta, field.NewPath("metadata"))...)
        if len(allErrors) > 0 {
                return allErrors
        }

        // Don't validate spec.  Strategy has stomped it.

        // There can be at most one of the known conditions, and it must have status "True"
        numKnownConditions := 0
        for i, cond := range newReq.Status.Conditions {
                switch cond.Type {
                case certificates.PodCertificateRequestConditionTypeIssued, certificates.PodCertificateRequestConditionTypeDenied, certificates.PodCertificateRequestConditionTypeFailed:
                        numKnownConditions++
                        if numKnownConditions > 1 {
                                allErrors = append(allErrors, field.Invalid(field.NewPath("status", "conditions", formatIndex(i), "type"), cond.Type, `There may be at most one condition with type "Issued", "Denied", or "Failed"`))
                        }
                        if cond.Status != metav1.ConditionTrue {
                                allErrors = append(allErrors, field.NotSupported(field.NewPath("status", "conditions", formatIndex(i), "status"), cond.Status, []metav1.ConditionStatus{metav1.ConditionTrue}))
                        }
                default:
                        allErrors = append(allErrors, field.NotSupported(field.NewPath("status", "conditions", formatIndex(i), "type"), cond.Type, []string{certificates.PodCertificateRequestConditionTypeIssued, certificates.PodCertificateRequestConditionTypeDenied, certificates.PodCertificateRequestConditionTypeFailed}))
                }
        }

        allErrors = append(allErrors, metav1validation.ValidateConditions(newReq.Status.Conditions, field.NewPath("status", "conditions"))...)

        // Bail if something seems wrong with the conditions --- we use the
        // conditions to drive validation of the remainder of the status fields.
        if len(allErrors) > 0 {
                return allErrors
        }

        // Is the original PCR in a terminal condition?  If so, the entire status
        // field (including conditions) is immutable.  No more changes are
        // permitted.
        if pcrIsIssued(oldReq) || pcrIsDenied(oldReq) || pcrIsFailed(oldReq) {
                allErrors = append(allErrors, validateSemanticEquality(newReq.Status, oldReq.Status, field.NewPath("status"), "immutable after PodCertificateRequest is issued, denied, or failed")...)
                return allErrors
        }

        // Are we transitioning to the "denied" or "failed" terminal conditions?
        if pcrIsDenied(newReq) || pcrIsFailed(newReq) {
                // No other status fields may change besides conditions.
                wantStatus := certificates.PodCertificateRequestStatus{
                        Conditions: newReq.Status.Conditions,
                }
                allErrors = append(allErrors, validateSemanticEquality(newReq.Status, wantStatus, field.NewPath("status"), "non-condition status fields must be empty when denying or failing the PodCertificateRequest")...)
                return allErrors
        }

        // Are we transitioning to the "issued" terminal condition?
        if pcrIsIssued(newReq) {
                if len(newReq.Status.CertificateChain) > certificates.MaxCertificateChainSize {
                        allErrors = append(allErrors, field.TooLong(field.NewPath("status", "certificateChain"), newReq.Status.CertificateChain, certificates.MaxCertificateChainSize))
                        return allErrors
                }

                leafBlock, rest := pem.Decode([]byte(newReq.Status.CertificateChain))
                if leafBlock == nil {
                        allErrors = append(allErrors, field.Invalid(certChainPath, newReq.Status.CertificateChain, "issued certificate chain must contain at least one certificate"))
                        return allErrors
                }
                if leafBlock.Type != "CERTIFICATE" {
                        allErrors = append(allErrors, field.Invalid(certChainPath, newReq.Status.CertificateChain, "issued certificate chain must consist entirely of CERTIFICATE PEM blocks"))
                        return allErrors
                }

                leafCert, err := x509.ParseCertificate(leafBlock.Bytes)
                if err != nil {
                        allErrors = append(allErrors, field.Invalid(certChainPath, newReq.Status.CertificateChain, "leaf certificate does not parse as valid X.509"))
                        return allErrors
                }

                // Was the certificate issued to the public key in the spec?
                wantPKAny, err := x509.ParsePKIXPublicKey(oldReq.Spec.PKIXPublicKey)
                if err != nil {
                        allErrors = append(allErrors, field.Invalid(pkixPath, oldReq.Spec.PKIXPublicKey, "must be a valid PKIX-serialized public key"))
                        return allErrors
                }
                switch wantPK := wantPKAny.(type) {
                case ed25519.PublicKey:
                        if !wantPK.Equal(leafCert.PublicKey) {
                                allErrors = append(allErrors, field.Invalid(certChainPath, newReq.Status.CertificateChain, "leaf certificate was not issued to the requested public key"))
                                return allErrors
                        }
                case *rsa.PublicKey:
                        if !wantPK.Equal(leafCert.PublicKey) {
                                allErrors = append(allErrors, field.Invalid(certChainPath, newReq.Status.CertificateChain, "leaf certificate was not issued to the requested public key"))
                                return allErrors
                        }
                case *ecdsa.PublicKey:
                        if !wantPK.Equal(leafCert.PublicKey) {
                                allErrors = append(allErrors, field.Invalid(certChainPath, newReq.Status.CertificateChain, "leaf certificate was not issued to the requested public key"))
                                return allErrors
                        }
                }

                // All timestamps must be set.
                if newReq.Status.NotBefore == nil {
                        allErrors = append(allErrors, field.Required(notBeforePath, "must be present and consistent with the issued certificate"))
                }
                if newReq.Status.NotAfter == nil {
                        allErrors = append(allErrors, field.Required(notAfterPath, "must be present and consistent with the issued certificate"))
                }
                if newReq.Status.BeginRefreshAt == nil {
                        allErrors = append(allErrors, field.Required(beginRefreshPath, "must be present and in the range [notbefore+10min, notafter-10min]"))
                }
                if len(allErrors) > 0 {
                        return allErrors
                }

                // Validate that NotBefore is consistent with the status field, and within 5
                // minutes of the current time.
                if !newReq.Status.NotBefore.Time.Equal(leafCert.NotBefore) {
                        allErrors = append(allErrors, field.Invalid(notBeforePath, newReq.Status.NotBefore.Time, "must be set to the NotBefore time encoded in the leaf certificate"))
                        return allErrors
                }
                if !timeNear(newReq.Status.NotBefore.Time, clock.Now(), 5*time.Minute) {
                        allErrors = append(allErrors, field.Invalid(notBeforePath, newReq.Status.NotBefore.Time, "must be set to within 5 minutes of kube-apiserver's current time"))
                        return allErrors
                }

                // Validate that NotAfter is consistent with the status field
                if !newReq.Status.NotAfter.Time.Equal(leafCert.NotAfter) {
                        allErrors = append(allErrors, field.Invalid(notAfterPath, newReq.Status.NotAfter.Time, "must be set to the NotAfter time encoded in the leaf certificate"))
                        return allErrors
                }

                // Validate that leaf cert lifetime against minimum and maximum constraints.
                lifetime := leafCert.NotAfter.Sub(leafCert.NotBefore)
                if lifetime < 1*time.Hour {
                        allErrors = append(allErrors, field.Invalid(certChainPath, lifetime, "leaf certificate lifetime must be >= 1 hour"))
                        return allErrors
                }
                if lifetime > time.Duration(*newReq.Spec.MaxExpirationSeconds)*time.Second {
                        allErrors = append(allErrors, field.Invalid(certChainPath, lifetime, fmt.Sprintf("leaf certificate lifetime must be <= spec.maxExpirationSeconds (%v)", *newReq.Spec.MaxExpirationSeconds)))
                        return allErrors
                }

                // Validate that BeginRefreshAt is within limits.
                if newReq.Status.BeginRefreshAt.Time.Before(newReq.Status.NotBefore.Time.Add(10 * time.Minute)) {
                        allErrors = append(allErrors, field.Invalid(beginRefreshPath, newReq.Status.BeginRefreshAt.Time, "must be at least 10 minutes after status.notBefore"))
                        return allErrors
                }
                if newReq.Status.BeginRefreshAt.Time.After(newReq.Status.NotAfter.Time.Add(-10 * time.Minute)) {
                        allErrors = append(allErrors, field.Invalid(beginRefreshPath, newReq.Status.BeginRefreshAt.Time, "must be at least 10 minutes before status.notAfter"))
                        return allErrors
                }

                // Check the remainder of the certificates in the chain, if any.  We cannot
                // easily verify the chain, because the Golang X.509 libraries are wisely
                // written to prevent us from doing stupid things like verifying a partial
                // chain, but we can at least check that they are valid certificates.
                for {
                        var nextBlock *pem.Block
                        nextBlock, rest = pem.Decode(rest)
                        if nextBlock == nil {
                                break
                        }

                        if nextBlock.Type != "CERTIFICATE" {
                                allErrors = append(allErrors, field.Invalid(certChainPath, newReq.Status.CertificateChain, "issued certificate chain must consist entirely of CERTFICATE PEM blocks"))
                                return allErrors
                        }

                        _, err := x509.ParseCertificate(nextBlock.Bytes)
                        if err != nil {
                                allErrors = append(allErrors, field.Invalid(certChainPath, newReq.Status.CertificateChain, "intermediate certificate does not parse as valid X.509"))
                                return allErrors
                        }
                }

                return allErrors
        }

        // We are not transitioning to any terminal state.  The whole status object
        // is immutable.
        allErrors = append(allErrors, validateSemanticEquality(newReq.Status, oldReq.Status, field.NewPath("status"), `status is immutable unless transitioning to "Issued", "Denied", or "Failed"`)...)
        return allErrors
}

func pcrIsIssued(pcr *certificates.PodCertificateRequest) bool {
        for _, cond := range pcr.Status.Conditions {
                if cond.Type == certificates.PodCertificateRequestConditionTypeIssued && cond.Status == metav1.ConditionTrue {
                        return true
                }
        }
        return false
}

func pcrIsDenied(pcr *certificates.PodCertificateRequest) bool {
        for _, cond := range pcr.Status.Conditions {
                if cond.Type == certificates.PodCertificateRequestConditionTypeDenied && cond.Status == metav1.ConditionTrue {
                        return true
                }
        }
        return false
}

func pcrIsFailed(pcr *certificates.PodCertificateRequest) bool {
        for _, cond := range pcr.Status.Conditions {
                if cond.Type == certificates.PodCertificateRequestConditionTypeFailed && cond.Status == metav1.ConditionTrue {
                        return true
                }
        }
        return false
}

func formatIndex(i int) string {
        return "[" + strconv.Itoa(i) + "]"
}

// Similar to apivalidation.ValidateImmutableField but we can supply our own detail string.
func validateSemanticEquality(oldVal, newVal any, fldPath *field.Path, detail string) field.ErrorList {
        allErrs := field.ErrorList{}
        if !apiequality.Semantic.DeepEqual(oldVal, newVal) {
                allErrs = append(allErrs, field.Invalid(fldPath, field.OmitValueType{}, detail))
        }
        return allErrs
}

func timeNear(a, b time.Time, skew time.Duration) bool {
        return a.After(b.Add(-skew)) && a.Before(b.Add(skew))
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package certificates

import (
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CertificateSigningRequest) DeepCopyInto(out *CertificateSigningRequest) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateSigningRequest.
func (in *CertificateSigningRequest) DeepCopy() *CertificateSigningRequest {
        if in == nil {
                return nil
        }
        out := new(CertificateSigningRequest)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *CertificateSigningRequest) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CertificateSigningRequestCondition) DeepCopyInto(out *CertificateSigningRequestCondition) {
        *out = *in
        in.LastUpdateTime.DeepCopyInto(&out.LastUpdateTime)
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateSigningRequestCondition.
func (in *CertificateSigningRequestCondition) DeepCopy() *CertificateSigningRequestCondition {
        if in == nil {
                return nil
        }
        out := new(CertificateSigningRequestCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CertificateSigningRequestList) DeepCopyInto(out *CertificateSigningRequestList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]CertificateSigningRequest, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateSigningRequestList.
func (in *CertificateSigningRequestList) DeepCopy() *CertificateSigningRequestList {
        if in == nil {
                return nil
        }
        out := new(CertificateSigningRequestList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *CertificateSigningRequestList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CertificateSigningRequestSpec) DeepCopyInto(out *CertificateSigningRequestSpec) {
        *out = *in
        if in.Request != nil {
                in, out := &in.Request, &out.Request
                *out = make([]byte, len(*in))
                copy(*out, *in)
        }
        if in.ExpirationSeconds != nil {
                in, out := &in.ExpirationSeconds, &out.ExpirationSeconds
                *out = new(int32)
                **out = **in
        }
        if in.Usages != nil {
                in, out := &in.Usages, &out.Usages
                *out = make([]KeyUsage, len(*in))
                copy(*out, *in)
        }
        if in.Groups != nil {
                in, out := &in.Groups, &out.Groups
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Extra != nil {
                in, out := &in.Extra, &out.Extra
                *out = make(map[string]ExtraValue, len(*in))
                for key, val := range *in {
                        var outVal []string
                        if val == nil {
                                (*out)[key] = nil
                        } else {
                                in, out := &val, &outVal
                                *out = make(ExtraValue, len(*in))
                                copy(*out, *in)
                        }
                        (*out)[key] = outVal
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateSigningRequestSpec.
func (in *CertificateSigningRequestSpec) DeepCopy() *CertificateSigningRequestSpec {
        if in == nil {
                return nil
        }
        out := new(CertificateSigningRequestSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CertificateSigningRequestStatus) DeepCopyInto(out *CertificateSigningRequestStatus) {
        *out = *in
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]CertificateSigningRequestCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Certificate != nil {
                in, out := &in.Certificate, &out.Certificate
                *out = make([]byte, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CertificateSigningRequestStatus.
func (in *CertificateSigningRequestStatus) DeepCopy() *CertificateSigningRequestStatus {
        if in == nil {
                return nil
        }
        out := new(CertificateSigningRequestStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ClusterTrustBundle) DeepCopyInto(out *ClusterTrustBundle) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        out.Spec = in.Spec
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTrustBundle.
func (in *ClusterTrustBundle) DeepCopy() *ClusterTrustBundle {
        if in == nil {
                return nil
        }
        out := new(ClusterTrustBundle)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ClusterTrustBundle) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ClusterTrustBundleList) DeepCopyInto(out *ClusterTrustBundleList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ClusterTrustBundle, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTrustBundleList.
func (in *ClusterTrustBundleList) DeepCopy() *ClusterTrustBundleList {
        if in == nil {
                return nil
        }
        out := new(ClusterTrustBundleList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ClusterTrustBundleList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ClusterTrustBundleSpec) DeepCopyInto(out *ClusterTrustBundleSpec) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTrustBundleSpec.
func (in *ClusterTrustBundleSpec) DeepCopy() *ClusterTrustBundleSpec {
        if in == nil {
                return nil
        }
        out := new(ClusterTrustBundleSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in ExtraValue) DeepCopyInto(out *ExtraValue) {
        {
                in := &in
                *out = make(ExtraValue, len(*in))
                copy(*out, *in)
                return
        }
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExtraValue.
func (in ExtraValue) DeepCopy() ExtraValue {
        if in == nil {
                return nil
        }
        out := new(ExtraValue)
        in.DeepCopyInto(out)
        return *out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodCertificateRequest) DeepCopyInto(out *PodCertificateRequest) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodCertificateRequest.
func (in *PodCertificateRequest) DeepCopy() *PodCertificateRequest {
        if in == nil {
                return nil
        }
        out := new(PodCertificateRequest)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodCertificateRequest) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodCertificateRequestList) DeepCopyInto(out *PodCertificateRequestList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]PodCertificateRequest, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodCertificateRequestList.
func (in *PodCertificateRequestList) DeepCopy() *PodCertificateRequestList {
        if in == nil {
                return nil
        }
        out := new(PodCertificateRequestList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodCertificateRequestList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodCertificateRequestSpec) DeepCopyInto(out *PodCertificateRequestSpec) {
        *out = *in
        if in.MaxExpirationSeconds != nil {
                in, out := &in.MaxExpirationSeconds, &out.MaxExpirationSeconds
                *out = new(int32)
                **out = **in
        }
        if in.PKIXPublicKey != nil {
                in, out := &in.PKIXPublicKey, &out.PKIXPublicKey
                *out = make([]byte, len(*in))
                copy(*out, *in)
        }
        if in.ProofOfPossession != nil {
                in, out := &in.ProofOfPossession, &out.ProofOfPossession
                *out = make([]byte, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodCertificateRequestSpec.
func (in *PodCertificateRequestSpec) DeepCopy() *PodCertificateRequestSpec {
        if in == nil {
                return nil
        }
        out := new(PodCertificateRequestSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodCertificateRequestStatus) DeepCopyInto(out *PodCertificateRequestStatus) {
        *out = *in
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]v1.Condition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.NotBefore != nil {
                in, out := &in.NotBefore, &out.NotBefore
                *out = (*in).DeepCopy()
        }
        if in.BeginRefreshAt != nil {
                in, out := &in.BeginRefreshAt, &out.BeginRefreshAt
                *out = (*in).DeepCopy()
        }
        if in.NotAfter != nil {
                in, out := &in.NotAfter, &out.NotAfter
                *out = (*in).DeepCopy()
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodCertificateRequestStatus.
func (in *PodCertificateRequestStatus) DeepCopy() *PodCertificateRequestStatus {
        if in == nil {
                return nil
        }
        out := new(PodCertificateRequestStatus)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2018 The Kubernetes Authors.

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.
*/

// Package install installs the coordination API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/coordination"
        v1 "k8s.io/kubernetes/pkg/apis/coordination/v1"
        "k8s.io/kubernetes/pkg/apis/coordination/v1alpha2"
        "k8s.io/kubernetes/pkg/apis/coordination/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(coordination.AddToScheme(scheme))
        utilruntime.Must(v1alpha2.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion, v1alpha2.SchemeGroupVersion))
}

/*
Copyright 2018 The Kubernetes Authors.

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.
*/

package coordination

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "coordination.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder points to a list of functions added to Scheme.
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme applies all the stored functions to the scheme.
        AddToScheme = SchemeBuilder.AddToScheme
)

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        // TODO this gets cleaned up when the types are fixed
        scheme.AddKnownTypes(SchemeGroupVersion,
                &Lease{},
                &LeaseList{},
                &LeaseCandidate{},
                &LeaseCandidateList{},
        )
        return nil
}

/*
Copyright 2018 The Kubernetes Authors.

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.
*/

package v1

import (
        coordinationv1 "k8s.io/api/coordination/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "coordination.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &coordinationv1.SchemeBuilder
        // AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(RegisterDefaults)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        coordinationv1 "k8s.io/api/coordination/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        coordination "k8s.io/kubernetes/pkg/apis/coordination"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*coordinationv1.Lease)(nil), (*coordination.Lease)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Lease_To_coordination_Lease(a.(*coordinationv1.Lease), b.(*coordination.Lease), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.Lease)(nil), (*coordinationv1.Lease)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_Lease_To_v1_Lease(a.(*coordination.Lease), b.(*coordinationv1.Lease), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1.LeaseList)(nil), (*coordination.LeaseList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LeaseList_To_coordination_LeaseList(a.(*coordinationv1.LeaseList), b.(*coordination.LeaseList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseList)(nil), (*coordinationv1.LeaseList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseList_To_v1_LeaseList(a.(*coordination.LeaseList), b.(*coordinationv1.LeaseList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1.LeaseSpec)(nil), (*coordination.LeaseSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LeaseSpec_To_coordination_LeaseSpec(a.(*coordinationv1.LeaseSpec), b.(*coordination.LeaseSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseSpec)(nil), (*coordinationv1.LeaseSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseSpec_To_v1_LeaseSpec(a.(*coordination.LeaseSpec), b.(*coordinationv1.LeaseSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_Lease_To_coordination_Lease(in *coordinationv1.Lease, out *coordination.Lease, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_LeaseSpec_To_coordination_LeaseSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_Lease_To_coordination_Lease is an autogenerated conversion function.
func Convert_v1_Lease_To_coordination_Lease(in *coordinationv1.Lease, out *coordination.Lease, s conversion.Scope) error {
        return autoConvert_v1_Lease_To_coordination_Lease(in, out, s)
}

func autoConvert_coordination_Lease_To_v1_Lease(in *coordination.Lease, out *coordinationv1.Lease, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_coordination_LeaseSpec_To_v1_LeaseSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_coordination_Lease_To_v1_Lease is an autogenerated conversion function.
func Convert_coordination_Lease_To_v1_Lease(in *coordination.Lease, out *coordinationv1.Lease, s conversion.Scope) error {
        return autoConvert_coordination_Lease_To_v1_Lease(in, out, s)
}

func autoConvert_v1_LeaseList_To_coordination_LeaseList(in *coordinationv1.LeaseList, out *coordination.LeaseList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]coordination.Lease)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_LeaseList_To_coordination_LeaseList is an autogenerated conversion function.
func Convert_v1_LeaseList_To_coordination_LeaseList(in *coordinationv1.LeaseList, out *coordination.LeaseList, s conversion.Scope) error {
        return autoConvert_v1_LeaseList_To_coordination_LeaseList(in, out, s)
}

func autoConvert_coordination_LeaseList_To_v1_LeaseList(in *coordination.LeaseList, out *coordinationv1.LeaseList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]coordinationv1.Lease)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_coordination_LeaseList_To_v1_LeaseList is an autogenerated conversion function.
func Convert_coordination_LeaseList_To_v1_LeaseList(in *coordination.LeaseList, out *coordinationv1.LeaseList, s conversion.Scope) error {
        return autoConvert_coordination_LeaseList_To_v1_LeaseList(in, out, s)
}

func autoConvert_v1_LeaseSpec_To_coordination_LeaseSpec(in *coordinationv1.LeaseSpec, out *coordination.LeaseSpec, s conversion.Scope) error {
        out.HolderIdentity = (*string)(unsafe.Pointer(in.HolderIdentity))
        out.LeaseDurationSeconds = (*int32)(unsafe.Pointer(in.LeaseDurationSeconds))
        out.AcquireTime = (*metav1.MicroTime)(unsafe.Pointer(in.AcquireTime))
        out.RenewTime = (*metav1.MicroTime)(unsafe.Pointer(in.RenewTime))
        out.LeaseTransitions = (*int32)(unsafe.Pointer(in.LeaseTransitions))
        out.Strategy = (*coordination.CoordinatedLeaseStrategy)(unsafe.Pointer(in.Strategy))
        out.PreferredHolder = (*string)(unsafe.Pointer(in.PreferredHolder))
        return nil
}

// Convert_v1_LeaseSpec_To_coordination_LeaseSpec is an autogenerated conversion function.
func Convert_v1_LeaseSpec_To_coordination_LeaseSpec(in *coordinationv1.LeaseSpec, out *coordination.LeaseSpec, s conversion.Scope) error {
        return autoConvert_v1_LeaseSpec_To_coordination_LeaseSpec(in, out, s)
}

func autoConvert_coordination_LeaseSpec_To_v1_LeaseSpec(in *coordination.LeaseSpec, out *coordinationv1.LeaseSpec, s conversion.Scope) error {
        out.HolderIdentity = (*string)(unsafe.Pointer(in.HolderIdentity))
        out.LeaseDurationSeconds = (*int32)(unsafe.Pointer(in.LeaseDurationSeconds))
        out.AcquireTime = (*metav1.MicroTime)(unsafe.Pointer(in.AcquireTime))
        out.RenewTime = (*metav1.MicroTime)(unsafe.Pointer(in.RenewTime))
        out.LeaseTransitions = (*int32)(unsafe.Pointer(in.LeaseTransitions))
        out.Strategy = (*coordinationv1.CoordinatedLeaseStrategy)(unsafe.Pointer(in.Strategy))
        out.PreferredHolder = (*string)(unsafe.Pointer(in.PreferredHolder))
        return nil
}

// Convert_coordination_LeaseSpec_To_v1_LeaseSpec is an autogenerated conversion function.
func Convert_coordination_LeaseSpec_To_v1_LeaseSpec(in *coordination.LeaseSpec, out *coordinationv1.LeaseSpec, s conversion.Scope) error {
        return autoConvert_coordination_LeaseSpec_To_v1_LeaseSpec(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

/*
Copyright 2024 The Kubernetes Authors.

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.
*/

package v1alpha2

import (
        coordinationv1alpha2 "k8s.io/api/coordination/v1alpha2"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "coordination.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha2"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &coordinationv1alpha2.SchemeBuilder
        // AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(RegisterDefaults)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1alpha2

import (
        unsafe "unsafe"

        coordinationv1 "k8s.io/api/coordination/v1"
        coordinationv1alpha2 "k8s.io/api/coordination/v1alpha2"
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        coordination "k8s.io/kubernetes/pkg/apis/coordination"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*coordinationv1alpha2.LeaseCandidate)(nil), (*coordination.LeaseCandidate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha2_LeaseCandidate_To_coordination_LeaseCandidate(a.(*coordinationv1alpha2.LeaseCandidate), b.(*coordination.LeaseCandidate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseCandidate)(nil), (*coordinationv1alpha2.LeaseCandidate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseCandidate_To_v1alpha2_LeaseCandidate(a.(*coordination.LeaseCandidate), b.(*coordinationv1alpha2.LeaseCandidate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1alpha2.LeaseCandidateList)(nil), (*coordination.LeaseCandidateList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha2_LeaseCandidateList_To_coordination_LeaseCandidateList(a.(*coordinationv1alpha2.LeaseCandidateList), b.(*coordination.LeaseCandidateList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseCandidateList)(nil), (*coordinationv1alpha2.LeaseCandidateList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseCandidateList_To_v1alpha2_LeaseCandidateList(a.(*coordination.LeaseCandidateList), b.(*coordinationv1alpha2.LeaseCandidateList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1alpha2.LeaseCandidateSpec)(nil), (*coordination.LeaseCandidateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1alpha2_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(a.(*coordinationv1alpha2.LeaseCandidateSpec), b.(*coordination.LeaseCandidateSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseCandidateSpec)(nil), (*coordinationv1alpha2.LeaseCandidateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseCandidateSpec_To_v1alpha2_LeaseCandidateSpec(a.(*coordination.LeaseCandidateSpec), b.(*coordinationv1alpha2.LeaseCandidateSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1alpha2_LeaseCandidate_To_coordination_LeaseCandidate(in *coordinationv1alpha2.LeaseCandidate, out *coordination.LeaseCandidate, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1alpha2_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1alpha2_LeaseCandidate_To_coordination_LeaseCandidate is an autogenerated conversion function.
func Convert_v1alpha2_LeaseCandidate_To_coordination_LeaseCandidate(in *coordinationv1alpha2.LeaseCandidate, out *coordination.LeaseCandidate, s conversion.Scope) error {
        return autoConvert_v1alpha2_LeaseCandidate_To_coordination_LeaseCandidate(in, out, s)
}

func autoConvert_coordination_LeaseCandidate_To_v1alpha2_LeaseCandidate(in *coordination.LeaseCandidate, out *coordinationv1alpha2.LeaseCandidate, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_coordination_LeaseCandidateSpec_To_v1alpha2_LeaseCandidateSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_coordination_LeaseCandidate_To_v1alpha2_LeaseCandidate is an autogenerated conversion function.
func Convert_coordination_LeaseCandidate_To_v1alpha2_LeaseCandidate(in *coordination.LeaseCandidate, out *coordinationv1alpha2.LeaseCandidate, s conversion.Scope) error {
        return autoConvert_coordination_LeaseCandidate_To_v1alpha2_LeaseCandidate(in, out, s)
}

func autoConvert_v1alpha2_LeaseCandidateList_To_coordination_LeaseCandidateList(in *coordinationv1alpha2.LeaseCandidateList, out *coordination.LeaseCandidateList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]coordination.LeaseCandidate)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1alpha2_LeaseCandidateList_To_coordination_LeaseCandidateList is an autogenerated conversion function.
func Convert_v1alpha2_LeaseCandidateList_To_coordination_LeaseCandidateList(in *coordinationv1alpha2.LeaseCandidateList, out *coordination.LeaseCandidateList, s conversion.Scope) error {
        return autoConvert_v1alpha2_LeaseCandidateList_To_coordination_LeaseCandidateList(in, out, s)
}

func autoConvert_coordination_LeaseCandidateList_To_v1alpha2_LeaseCandidateList(in *coordination.LeaseCandidateList, out *coordinationv1alpha2.LeaseCandidateList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]coordinationv1alpha2.LeaseCandidate)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_coordination_LeaseCandidateList_To_v1alpha2_LeaseCandidateList is an autogenerated conversion function.
func Convert_coordination_LeaseCandidateList_To_v1alpha2_LeaseCandidateList(in *coordination.LeaseCandidateList, out *coordinationv1alpha2.LeaseCandidateList, s conversion.Scope) error {
        return autoConvert_coordination_LeaseCandidateList_To_v1alpha2_LeaseCandidateList(in, out, s)
}

func autoConvert_v1alpha2_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(in *coordinationv1alpha2.LeaseCandidateSpec, out *coordination.LeaseCandidateSpec, s conversion.Scope) error {
        out.LeaseName = in.LeaseName
        out.PingTime = (*v1.MicroTime)(unsafe.Pointer(in.PingTime))
        out.RenewTime = (*v1.MicroTime)(unsafe.Pointer(in.RenewTime))
        out.BinaryVersion = in.BinaryVersion
        out.EmulationVersion = in.EmulationVersion
        out.Strategy = coordination.CoordinatedLeaseStrategy(in.Strategy)
        return nil
}

// Convert_v1alpha2_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec is an autogenerated conversion function.
func Convert_v1alpha2_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(in *coordinationv1alpha2.LeaseCandidateSpec, out *coordination.LeaseCandidateSpec, s conversion.Scope) error {
        return autoConvert_v1alpha2_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(in, out, s)
}

func autoConvert_coordination_LeaseCandidateSpec_To_v1alpha2_LeaseCandidateSpec(in *coordination.LeaseCandidateSpec, out *coordinationv1alpha2.LeaseCandidateSpec, s conversion.Scope) error {
        out.LeaseName = in.LeaseName
        out.PingTime = (*v1.MicroTime)(unsafe.Pointer(in.PingTime))
        out.RenewTime = (*v1.MicroTime)(unsafe.Pointer(in.RenewTime))
        out.BinaryVersion = in.BinaryVersion
        out.EmulationVersion = in.EmulationVersion
        out.Strategy = coordinationv1.CoordinatedLeaseStrategy(in.Strategy)
        return nil
}

// Convert_coordination_LeaseCandidateSpec_To_v1alpha2_LeaseCandidateSpec is an autogenerated conversion function.
func Convert_coordination_LeaseCandidateSpec_To_v1alpha2_LeaseCandidateSpec(in *coordination.LeaseCandidateSpec, out *coordinationv1alpha2.LeaseCandidateSpec, s conversion.Scope) error {
        return autoConvert_coordination_LeaseCandidateSpec_To_v1alpha2_LeaseCandidateSpec(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1alpha2

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

/*
Copyright 2018 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        coordinationv1beta1 "k8s.io/api/coordination/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "coordination.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &coordinationv1beta1.SchemeBuilder
        // AddToScheme is a common registration function for mapping packaged scoped group & version keys to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(RegisterDefaults)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        coordinationv1 "k8s.io/api/coordination/v1"
        coordinationv1beta1 "k8s.io/api/coordination/v1beta1"
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        coordination "k8s.io/kubernetes/pkg/apis/coordination"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*coordinationv1beta1.Lease)(nil), (*coordination.Lease)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Lease_To_coordination_Lease(a.(*coordinationv1beta1.Lease), b.(*coordination.Lease), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.Lease)(nil), (*coordinationv1beta1.Lease)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_Lease_To_v1beta1_Lease(a.(*coordination.Lease), b.(*coordinationv1beta1.Lease), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1beta1.LeaseCandidate)(nil), (*coordination.LeaseCandidate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_LeaseCandidate_To_coordination_LeaseCandidate(a.(*coordinationv1beta1.LeaseCandidate), b.(*coordination.LeaseCandidate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseCandidate)(nil), (*coordinationv1beta1.LeaseCandidate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseCandidate_To_v1beta1_LeaseCandidate(a.(*coordination.LeaseCandidate), b.(*coordinationv1beta1.LeaseCandidate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1beta1.LeaseCandidateList)(nil), (*coordination.LeaseCandidateList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_LeaseCandidateList_To_coordination_LeaseCandidateList(a.(*coordinationv1beta1.LeaseCandidateList), b.(*coordination.LeaseCandidateList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseCandidateList)(nil), (*coordinationv1beta1.LeaseCandidateList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseCandidateList_To_v1beta1_LeaseCandidateList(a.(*coordination.LeaseCandidateList), b.(*coordinationv1beta1.LeaseCandidateList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1beta1.LeaseCandidateSpec)(nil), (*coordination.LeaseCandidateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(a.(*coordinationv1beta1.LeaseCandidateSpec), b.(*coordination.LeaseCandidateSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseCandidateSpec)(nil), (*coordinationv1beta1.LeaseCandidateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseCandidateSpec_To_v1beta1_LeaseCandidateSpec(a.(*coordination.LeaseCandidateSpec), b.(*coordinationv1beta1.LeaseCandidateSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1beta1.LeaseList)(nil), (*coordination.LeaseList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_LeaseList_To_coordination_LeaseList(a.(*coordinationv1beta1.LeaseList), b.(*coordination.LeaseList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseList)(nil), (*coordinationv1beta1.LeaseList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseList_To_v1beta1_LeaseList(a.(*coordination.LeaseList), b.(*coordinationv1beta1.LeaseList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordinationv1beta1.LeaseSpec)(nil), (*coordination.LeaseSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_LeaseSpec_To_coordination_LeaseSpec(a.(*coordinationv1beta1.LeaseSpec), b.(*coordination.LeaseSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*coordination.LeaseSpec)(nil), (*coordinationv1beta1.LeaseSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_coordination_LeaseSpec_To_v1beta1_LeaseSpec(a.(*coordination.LeaseSpec), b.(*coordinationv1beta1.LeaseSpec), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_Lease_To_coordination_Lease(in *coordinationv1beta1.Lease, out *coordination.Lease, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_LeaseSpec_To_coordination_LeaseSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_Lease_To_coordination_Lease is an autogenerated conversion function.
func Convert_v1beta1_Lease_To_coordination_Lease(in *coordinationv1beta1.Lease, out *coordination.Lease, s conversion.Scope) error {
        return autoConvert_v1beta1_Lease_To_coordination_Lease(in, out, s)
}

func autoConvert_coordination_Lease_To_v1beta1_Lease(in *coordination.Lease, out *coordinationv1beta1.Lease, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_coordination_LeaseSpec_To_v1beta1_LeaseSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_coordination_Lease_To_v1beta1_Lease is an autogenerated conversion function.
func Convert_coordination_Lease_To_v1beta1_Lease(in *coordination.Lease, out *coordinationv1beta1.Lease, s conversion.Scope) error {
        return autoConvert_coordination_Lease_To_v1beta1_Lease(in, out, s)
}

func autoConvert_v1beta1_LeaseCandidate_To_coordination_LeaseCandidate(in *coordinationv1beta1.LeaseCandidate, out *coordination.LeaseCandidate, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_LeaseCandidate_To_coordination_LeaseCandidate is an autogenerated conversion function.
func Convert_v1beta1_LeaseCandidate_To_coordination_LeaseCandidate(in *coordinationv1beta1.LeaseCandidate, out *coordination.LeaseCandidate, s conversion.Scope) error {
        return autoConvert_v1beta1_LeaseCandidate_To_coordination_LeaseCandidate(in, out, s)
}

func autoConvert_coordination_LeaseCandidate_To_v1beta1_LeaseCandidate(in *coordination.LeaseCandidate, out *coordinationv1beta1.LeaseCandidate, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_coordination_LeaseCandidateSpec_To_v1beta1_LeaseCandidateSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_coordination_LeaseCandidate_To_v1beta1_LeaseCandidate is an autogenerated conversion function.
func Convert_coordination_LeaseCandidate_To_v1beta1_LeaseCandidate(in *coordination.LeaseCandidate, out *coordinationv1beta1.LeaseCandidate, s conversion.Scope) error {
        return autoConvert_coordination_LeaseCandidate_To_v1beta1_LeaseCandidate(in, out, s)
}

func autoConvert_v1beta1_LeaseCandidateList_To_coordination_LeaseCandidateList(in *coordinationv1beta1.LeaseCandidateList, out *coordination.LeaseCandidateList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]coordination.LeaseCandidate)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1beta1_LeaseCandidateList_To_coordination_LeaseCandidateList is an autogenerated conversion function.
func Convert_v1beta1_LeaseCandidateList_To_coordination_LeaseCandidateList(in *coordinationv1beta1.LeaseCandidateList, out *coordination.LeaseCandidateList, s conversion.Scope) error {
        return autoConvert_v1beta1_LeaseCandidateList_To_coordination_LeaseCandidateList(in, out, s)
}

func autoConvert_coordination_LeaseCandidateList_To_v1beta1_LeaseCandidateList(in *coordination.LeaseCandidateList, out *coordinationv1beta1.LeaseCandidateList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]coordinationv1beta1.LeaseCandidate)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_coordination_LeaseCandidateList_To_v1beta1_LeaseCandidateList is an autogenerated conversion function.
func Convert_coordination_LeaseCandidateList_To_v1beta1_LeaseCandidateList(in *coordination.LeaseCandidateList, out *coordinationv1beta1.LeaseCandidateList, s conversion.Scope) error {
        return autoConvert_coordination_LeaseCandidateList_To_v1beta1_LeaseCandidateList(in, out, s)
}

func autoConvert_v1beta1_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(in *coordinationv1beta1.LeaseCandidateSpec, out *coordination.LeaseCandidateSpec, s conversion.Scope) error {
        out.LeaseName = in.LeaseName
        out.PingTime = (*v1.MicroTime)(unsafe.Pointer(in.PingTime))
        out.RenewTime = (*v1.MicroTime)(unsafe.Pointer(in.RenewTime))
        out.BinaryVersion = in.BinaryVersion
        out.EmulationVersion = in.EmulationVersion
        out.Strategy = coordination.CoordinatedLeaseStrategy(in.Strategy)
        return nil
}

// Convert_v1beta1_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec is an autogenerated conversion function.
func Convert_v1beta1_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(in *coordinationv1beta1.LeaseCandidateSpec, out *coordination.LeaseCandidateSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_LeaseCandidateSpec_To_coordination_LeaseCandidateSpec(in, out, s)
}

func autoConvert_coordination_LeaseCandidateSpec_To_v1beta1_LeaseCandidateSpec(in *coordination.LeaseCandidateSpec, out *coordinationv1beta1.LeaseCandidateSpec, s conversion.Scope) error {
        out.LeaseName = in.LeaseName
        out.PingTime = (*v1.MicroTime)(unsafe.Pointer(in.PingTime))
        out.RenewTime = (*v1.MicroTime)(unsafe.Pointer(in.RenewTime))
        out.BinaryVersion = in.BinaryVersion
        out.EmulationVersion = in.EmulationVersion
        out.Strategy = coordinationv1.CoordinatedLeaseStrategy(in.Strategy)
        return nil
}

// Convert_coordination_LeaseCandidateSpec_To_v1beta1_LeaseCandidateSpec is an autogenerated conversion function.
func Convert_coordination_LeaseCandidateSpec_To_v1beta1_LeaseCandidateSpec(in *coordination.LeaseCandidateSpec, out *coordinationv1beta1.LeaseCandidateSpec, s conversion.Scope) error {
        return autoConvert_coordination_LeaseCandidateSpec_To_v1beta1_LeaseCandidateSpec(in, out, s)
}

func autoConvert_v1beta1_LeaseList_To_coordination_LeaseList(in *coordinationv1beta1.LeaseList, out *coordination.LeaseList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]coordination.Lease)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1beta1_LeaseList_To_coordination_LeaseList is an autogenerated conversion function.
func Convert_v1beta1_LeaseList_To_coordination_LeaseList(in *coordinationv1beta1.LeaseList, out *coordination.LeaseList, s conversion.Scope) error {
        return autoConvert_v1beta1_LeaseList_To_coordination_LeaseList(in, out, s)
}

func autoConvert_coordination_LeaseList_To_v1beta1_LeaseList(in *coordination.LeaseList, out *coordinationv1beta1.LeaseList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]coordinationv1beta1.Lease)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_coordination_LeaseList_To_v1beta1_LeaseList is an autogenerated conversion function.
func Convert_coordination_LeaseList_To_v1beta1_LeaseList(in *coordination.LeaseList, out *coordinationv1beta1.LeaseList, s conversion.Scope) error {
        return autoConvert_coordination_LeaseList_To_v1beta1_LeaseList(in, out, s)
}

func autoConvert_v1beta1_LeaseSpec_To_coordination_LeaseSpec(in *coordinationv1beta1.LeaseSpec, out *coordination.LeaseSpec, s conversion.Scope) error {
        out.HolderIdentity = (*string)(unsafe.Pointer(in.HolderIdentity))
        out.LeaseDurationSeconds = (*int32)(unsafe.Pointer(in.LeaseDurationSeconds))
        out.AcquireTime = (*v1.MicroTime)(unsafe.Pointer(in.AcquireTime))
        out.RenewTime = (*v1.MicroTime)(unsafe.Pointer(in.RenewTime))
        out.LeaseTransitions = (*int32)(unsafe.Pointer(in.LeaseTransitions))
        out.Strategy = (*coordination.CoordinatedLeaseStrategy)(unsafe.Pointer(in.Strategy))
        out.PreferredHolder = (*string)(unsafe.Pointer(in.PreferredHolder))
        return nil
}

// Convert_v1beta1_LeaseSpec_To_coordination_LeaseSpec is an autogenerated conversion function.
func Convert_v1beta1_LeaseSpec_To_coordination_LeaseSpec(in *coordinationv1beta1.LeaseSpec, out *coordination.LeaseSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_LeaseSpec_To_coordination_LeaseSpec(in, out, s)
}

func autoConvert_coordination_LeaseSpec_To_v1beta1_LeaseSpec(in *coordination.LeaseSpec, out *coordinationv1beta1.LeaseSpec, s conversion.Scope) error {
        out.HolderIdentity = (*string)(unsafe.Pointer(in.HolderIdentity))
        out.LeaseDurationSeconds = (*int32)(unsafe.Pointer(in.LeaseDurationSeconds))
        out.AcquireTime = (*v1.MicroTime)(unsafe.Pointer(in.AcquireTime))
        out.RenewTime = (*v1.MicroTime)(unsafe.Pointer(in.RenewTime))
        out.LeaseTransitions = (*int32)(unsafe.Pointer(in.LeaseTransitions))
        out.Strategy = (*coordinationv1.CoordinatedLeaseStrategy)(unsafe.Pointer(in.Strategy))
        out.PreferredHolder = (*string)(unsafe.Pointer(in.PreferredHolder))
        return nil
}

// Convert_coordination_LeaseSpec_To_v1beta1_LeaseSpec is an autogenerated conversion function.
func Convert_coordination_LeaseSpec_To_v1beta1_LeaseSpec(in *coordination.LeaseSpec, out *coordinationv1beta1.LeaseSpec, s conversion.Scope) error {
        return autoConvert_coordination_LeaseSpec_To_v1beta1_LeaseSpec(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package coordination

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Lease) DeepCopyInto(out *Lease) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Lease.
func (in *Lease) DeepCopy() *Lease {
        if in == nil {
                return nil
        }
        out := new(Lease)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Lease) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LeaseCandidate) DeepCopyInto(out *LeaseCandidate) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LeaseCandidate.
func (in *LeaseCandidate) DeepCopy() *LeaseCandidate {
        if in == nil {
                return nil
        }
        out := new(LeaseCandidate)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *LeaseCandidate) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LeaseCandidateList) DeepCopyInto(out *LeaseCandidateList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]LeaseCandidate, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LeaseCandidateList.
func (in *LeaseCandidateList) DeepCopy() *LeaseCandidateList {
        if in == nil {
                return nil
        }
        out := new(LeaseCandidateList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *LeaseCandidateList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LeaseCandidateSpec) DeepCopyInto(out *LeaseCandidateSpec) {
        *out = *in
        if in.PingTime != nil {
                in, out := &in.PingTime, &out.PingTime
                *out = (*in).DeepCopy()
        }
        if in.RenewTime != nil {
                in, out := &in.RenewTime, &out.RenewTime
                *out = (*in).DeepCopy()
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LeaseCandidateSpec.
func (in *LeaseCandidateSpec) DeepCopy() *LeaseCandidateSpec {
        if in == nil {
                return nil
        }
        out := new(LeaseCandidateSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LeaseList) DeepCopyInto(out *LeaseList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Lease, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LeaseList.
func (in *LeaseList) DeepCopy() *LeaseList {
        if in == nil {
                return nil
        }
        out := new(LeaseList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *LeaseList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LeaseSpec) DeepCopyInto(out *LeaseSpec) {
        *out = *in
        if in.HolderIdentity != nil {
                in, out := &in.HolderIdentity, &out.HolderIdentity
                *out = new(string)
                **out = **in
        }
        if in.LeaseDurationSeconds != nil {
                in, out := &in.LeaseDurationSeconds, &out.LeaseDurationSeconds
                *out = new(int32)
                **out = **in
        }
        if in.AcquireTime != nil {
                in, out := &in.AcquireTime, &out.AcquireTime
                *out = (*in).DeepCopy()
        }
        if in.RenewTime != nil {
                in, out := &in.RenewTime, &out.RenewTime
                *out = (*in).DeepCopy()
        }
        if in.LeaseTransitions != nil {
                in, out := &in.LeaseTransitions, &out.LeaseTransitions
                *out = new(int32)
                **out = **in
        }
        if in.Strategy != nil {
                in, out := &in.Strategy, &out.Strategy
                *out = new(CoordinatedLeaseStrategy)
                **out = **in
        }
        if in.PreferredHolder != nil {
                in, out := &in.PreferredHolder, &out.PreferredHolder
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LeaseSpec.
func (in *LeaseSpec) DeepCopy() *LeaseSpec {
        if in == nil {
                return nil
        }
        out := new(LeaseSpec)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        "reflect"
        "strconv"
        "time"

        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/api/resource"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
        "k8s.io/apimachinery/pkg/util/intstr"
        "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/utils/ptr"
        "sigs.k8s.io/randfill"
)

// Funcs returns the fuzzer functions for the core group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(q *resource.Quantity, c randfill.Continue) {
                        *q = *resource.NewQuantity(c.Int63n(1000), resource.DecimalExponent)
                },
                func(j *core.ObjectReference, c randfill.Continue) {
                        // We have to customize the randomization of TypeMetas because their
                        // APIVersion and Kind must remain blank in memory.
                        j.APIVersion = c.String(0)
                        j.Kind = c.String(0)
                        j.Namespace = c.String(0)
                        j.Name = c.String(0)
                        j.ResourceVersion = strconv.FormatUint(c.Uint64(), 10)
                        j.FieldPath = c.String(0)
                },
                func(j *core.PodExecOptions, c randfill.Continue) {
                        j.Stdout = true
                        j.Stderr = true
                },
                func(j *core.PodAttachOptions, c randfill.Continue) {
                        j.Stdout = true
                        j.Stderr = true
                },
                func(j *core.PodPortForwardOptions, c randfill.Continue) {
                        if c.Bool() {
                                j.Ports = make([]int32, c.Intn(10))
                                for i := range j.Ports {
                                        j.Ports[i] = c.Int31n(65535)
                                }
                        }
                },
                func(s *core.PodSpec, c randfill.Continue) {
                        c.FillNoCustom(s)
                        // has a default value
                        ttl := int64(30)
                        if c.Bool() {
                                ttl = int64(c.Uint32())
                        }
                        s.TerminationGracePeriodSeconds = &ttl

                        c.Fill(s.SecurityContext)

                        if s.SecurityContext == nil {
                                s.SecurityContext = new(core.PodSecurityContext)
                        }
                        if s.Affinity == nil {
                                s.Affinity = new(core.Affinity)
                        }
                        if s.SchedulerName == "" {
                                s.SchedulerName = v1.DefaultSchedulerName
                        }
                        if s.EnableServiceLinks == nil {
                                enableServiceLinks := v1.DefaultEnableServiceLinks
                                s.EnableServiceLinks = &enableServiceLinks
                        }
                },
                func(s *core.PodStatus, c randfill.Continue) {
                        c.Fill(&s)
                        s.HostIPs = []core.HostIP{{IP: s.HostIP}}
                },
                func(j *core.PodPhase, c randfill.Continue) {
                        statuses := []core.PodPhase{core.PodPending, core.PodRunning, core.PodFailed, core.PodUnknown}
                        *j = statuses[c.Rand.Intn(len(statuses))]
                },
                func(j *core.Binding, c randfill.Continue) {
                        c.Fill(&j.ObjectMeta)
                        j.Target.Name = c.String(0)
                },
                func(j *core.ReplicationController, c randfill.Continue) {
                        c.FillNoCustom(j)

                        // match defaulting
                        if j.Spec.Template != nil {
                                if len(j.Labels) == 0 {
                                        j.Labels = j.Spec.Template.Labels
                                }
                                if len(j.Spec.Selector) == 0 {
                                        j.Spec.Selector = j.Spec.Template.Labels
                                }
                        }
                },
                func(j *core.ReplicationControllerSpec, c randfill.Continue) {
                        c.FillNoCustom(j) // fuzz self without calling this function again
                        //j.TemplateRef = nil // this is required for round trip

                        // match defaulting
                        if j.Replicas == nil {
                                replicas := int32(0)
                                j.Replicas = &replicas
                        }
                },
                func(j *core.List, c randfill.Continue) {
                        c.FillNoCustom(j) // fuzz self without calling this function again
                        // TODO: uncomment when round trip starts from a versioned object
                        if false { //j.Items == nil {
                                j.Items = []runtime.Object{}
                        }
                },
                func(q *core.ResourceRequirements, c randfill.Continue) {
                        randomQuantity := func() resource.Quantity {
                                var q resource.Quantity
                                c.Fill(&q)
                                // precalc the string for benchmarking purposes
                                _ = q.String()
                                return q
                        }
                        q.Limits = make(core.ResourceList)
                        q.Requests = make(core.ResourceList)
                        cpuLimit := randomQuantity()
                        q.Limits[core.ResourceCPU] = cpuLimit.DeepCopy()
                        q.Requests[core.ResourceCPU] = cpuLimit.DeepCopy()
                        memoryLimit := randomQuantity()
                        q.Limits[core.ResourceMemory] = memoryLimit.DeepCopy()
                        q.Requests[core.ResourceMemory] = memoryLimit.DeepCopy()
                        storageLimit := randomQuantity()
                        q.Limits[core.ResourceStorage] = storageLimit.DeepCopy()
                        q.Requests[core.ResourceStorage] = storageLimit.DeepCopy()
                },
                func(q *core.LimitRangeItem, c randfill.Continue) {
                        var cpuLimit resource.Quantity
                        c.Fill(&cpuLimit)

                        q.Type = core.LimitTypeContainer
                        q.Default = make(core.ResourceList)
                        q.Default[core.ResourceCPU] = cpuLimit.DeepCopy()

                        q.DefaultRequest = make(core.ResourceList)
                        q.DefaultRequest[core.ResourceCPU] = cpuLimit.DeepCopy()

                        q.Max = make(core.ResourceList)
                        q.Max[core.ResourceCPU] = cpuLimit.DeepCopy()

                        q.Min = make(core.ResourceList)
                        q.Min[core.ResourceCPU] = cpuLimit.DeepCopy()

                        q.MaxLimitRequestRatio = make(core.ResourceList)
                        q.MaxLimitRequestRatio[core.ResourceCPU] = resource.MustParse("10")
                },
                func(p *core.PullPolicy, c randfill.Continue) {
                        policies := []core.PullPolicy{core.PullAlways, core.PullNever, core.PullIfNotPresent}
                        *p = policies[c.Rand.Intn(len(policies))]
                },
                func(rp *core.RestartPolicy, c randfill.Continue) {
                        policies := []core.RestartPolicy{core.RestartPolicyAlways, core.RestartPolicyNever, core.RestartPolicyOnFailure}
                        *rp = policies[c.Rand.Intn(len(policies))]
                },
                // core.DownwardAPIVolumeFile needs to have a specific func since FieldRef has to be
                // defaulted to a version otherwise roundtrip will fail
                func(m *core.DownwardAPIVolumeFile, c randfill.Continue) {
                        m.Path = c.String(0)
                        versions := []string{"v1"}
                        m.FieldRef = &core.ObjectFieldSelector{}
                        m.FieldRef.APIVersion = versions[c.Rand.Intn(len(versions))]
                        m.FieldRef.FieldPath = c.String(0)
                        c.Fill(m.Mode)
                        if m.Mode != nil {
                                *m.Mode &= 0777
                        }
                },
                func(s *core.SecretVolumeSource, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again

                        if c.Bool() {
                                opt := c.Bool()
                                s.Optional = &opt
                        }
                        // DefaultMode should always be set, it has a default
                        // value and it is expected to be between 0 and 0777
                        var mode int32
                        c.Fill(&mode)
                        mode &= 0777
                        s.DefaultMode = &mode
                },
                func(cm *core.ConfigMapVolumeSource, c randfill.Continue) {
                        c.FillNoCustom(cm) // fuzz self without calling this function again

                        if c.Bool() {
                                opt := c.Bool()
                                cm.Optional = &opt
                        }
                        // DefaultMode should always be set, it has a default
                        // value and it is expected to be between 0 and 0777
                        var mode int32
                        c.Fill(&mode)
                        mode &= 0777
                        cm.DefaultMode = &mode
                },
                func(d *core.DownwardAPIVolumeSource, c randfill.Continue) {
                        c.FillNoCustom(d) // fuzz self without calling this function again

                        // DefaultMode should always be set, it has a default
                        // value and it is expected to be between 0 and 0777
                        var mode int32
                        c.Fill(&mode)
                        mode &= 0777
                        d.DefaultMode = &mode
                },
                func(s *core.ProjectedVolumeSource, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again

                        // DefaultMode should always be set, it has a default
                        // value and it is expected to be between 0 and 0777
                        var mode int32
                        c.Fill(&mode)
                        mode &= 0777
                        s.DefaultMode = &mode
                },
                func(k *core.KeyToPath, c randfill.Continue) {
                        c.FillNoCustom(k) // fuzz self without calling this function again
                        k.Key = c.String(0)
                        k.Path = c.String(0)

                        // Mode is not mandatory, but if it is set, it should be
                        // a value between 0 and 0777
                        if k.Mode != nil {
                                *k.Mode &= 0777
                        }
                },
                func(vs *core.VolumeSource, c randfill.Continue) {
                        // Exactly one of the fields must be set.
                        v := reflect.ValueOf(vs).Elem()
                        i := int(c.Uint64() % uint64(v.NumField()))
                        t := v.Field(i).Addr()
                        for v.Field(i).IsNil() {
                                c.Fill(t.Interface())
                        }
                },
                func(i *core.ISCSIVolumeSource, c randfill.Continue) {
                        i.ISCSIInterface = c.String(0)
                        if i.ISCSIInterface == "" {
                                i.ISCSIInterface = "default"
                        }
                },
                func(i *core.ISCSIPersistentVolumeSource, c randfill.Continue) {
                        i.ISCSIInterface = c.String(0)
                        if i.ISCSIInterface == "" {
                                i.ISCSIInterface = "default"
                        }
                },
                func(i *core.PersistentVolumeClaimSpec, c randfill.Continue) {
                        // Match defaulting in pkg/apis/core/v1/defaults.go.
                        volumeMode := core.PersistentVolumeMode(c.String(0))
                        if volumeMode == "" {
                                volumeMode = core.PersistentVolumeFilesystem
                        }
                        i.VolumeMode = &volumeMode
                },
                func(d *core.DNSPolicy, c randfill.Continue) {
                        policies := []core.DNSPolicy{core.DNSClusterFirst, core.DNSDefault}
                        *d = policies[c.Rand.Intn(len(policies))]
                },
                func(p *core.Protocol, c randfill.Continue) {
                        protocols := []core.Protocol{core.ProtocolTCP, core.ProtocolUDP, core.ProtocolSCTP}
                        *p = protocols[c.Rand.Intn(len(protocols))]
                },
                func(p *core.ServiceAffinity, c randfill.Continue) {
                        types := []core.ServiceAffinity{core.ServiceAffinityClientIP, core.ServiceAffinityNone}
                        *p = types[c.Rand.Intn(len(types))]
                },
                func(p *core.ServiceType, c randfill.Continue) {
                        types := []core.ServiceType{core.ServiceTypeClusterIP, core.ServiceTypeNodePort, core.ServiceTypeLoadBalancer}
                        *p = types[c.Rand.Intn(len(types))]
                },
                func(p *core.IPFamily, c randfill.Continue) {
                        types := []core.IPFamily{core.IPv4Protocol, core.IPv6Protocol}
                        selected := types[c.Rand.Intn(len(types))]
                        *p = selected
                },
                func(p *core.ServiceExternalTrafficPolicy, c randfill.Continue) {
                        types := []core.ServiceExternalTrafficPolicy{core.ServiceExternalTrafficPolicyCluster, core.ServiceExternalTrafficPolicyLocal}
                        *p = types[c.Rand.Intn(len(types))]
                },
                func(p *core.ServiceInternalTrafficPolicy, c randfill.Continue) {
                        types := []core.ServiceInternalTrafficPolicy{core.ServiceInternalTrafficPolicyCluster, core.ServiceInternalTrafficPolicyLocal}
                        *p = types[c.Rand.Intn(len(types))]
                },
                func(ct *core.Container, c randfill.Continue) {
                        c.FillNoCustom(ct)                                          // fuzz self without calling this function again
                        ct.TerminationMessagePath = "/" + ct.TerminationMessagePath // Must be non-empty
                        ct.TerminationMessagePolicy = "File"
                },
                func(ep *core.EphemeralContainer, c randfill.Continue) {
                        c.FillNoCustom(ep)                                                                   // fuzz self without calling this function again
                        ep.EphemeralContainerCommon.TerminationMessagePath = "/" + ep.TerminationMessagePath // Must be non-empty
                        ep.EphemeralContainerCommon.TerminationMessagePolicy = "File"
                },
                func(p *core.Probe, c randfill.Continue) {
                        c.FillNoCustom(p)
                        // These fields have default values.
                        intFieldsWithDefaults := [...]string{"TimeoutSeconds", "PeriodSeconds", "SuccessThreshold", "FailureThreshold"}
                        v := reflect.ValueOf(p).Elem()
                        for _, field := range intFieldsWithDefaults {
                                f := v.FieldByName(field)
                                if f.Int() == 0 {
                                        f.SetInt(1)
                                }
                        }
                },
                func(ev *core.EnvVar, c randfill.Continue) {
                        ev.Name = c.String(0)
                        if c.Bool() {
                                ev.Value = c.String(0)
                        } else {
                                ev.ValueFrom = &core.EnvVarSource{}
                                ev.ValueFrom.FieldRef = &core.ObjectFieldSelector{}

                                versions := []schema.GroupVersion{
                                        {Group: "admission.k8s.io", Version: "v1alpha1"},
                                        {Group: "apps", Version: "v1beta1"},
                                        {Group: "apps", Version: "v1beta2"},
                                        {Group: "foo", Version: "v42"},
                                }

                                ev.ValueFrom.FieldRef.APIVersion = versions[c.Rand.Intn(len(versions))].String()
                                ev.ValueFrom.FieldRef.FieldPath = c.String(0)
                        }
                },
                func(ev *core.EnvFromSource, c randfill.Continue) {
                        if c.Bool() {
                                ev.Prefix = "p_"
                        }
                        if c.Bool() {
                                c.Fill(&ev.ConfigMapRef)
                        } else {
                                c.Fill(&ev.SecretRef)
                        }
                },
                func(cm *core.ConfigMapEnvSource, c randfill.Continue) {
                        c.FillNoCustom(cm) // fuzz self without calling this function again
                        if c.Bool() {
                                opt := c.Bool()
                                cm.Optional = &opt
                        }
                },
                func(s *core.SecretEnvSource, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again
                },
                func(sc *core.SecurityContext, c randfill.Continue) {
                        c.FillNoCustom(sc) // fuzz self without calling this function again
                        if c.Bool() {
                                priv := c.Bool()
                                sc.Privileged = &priv
                        }

                        if c.Bool() {
                                sc.Capabilities = &core.Capabilities{
                                        Add:  make([]core.Capability, 0),
                                        Drop: make([]core.Capability, 0),
                                }
                                c.Fill(&sc.Capabilities.Add)
                                c.Fill(&sc.Capabilities.Drop)
                        }
                },
                func(s *core.Secret, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again
                        s.Type = core.SecretTypeOpaque
                },
                func(r *core.RBDVolumeSource, c randfill.Continue) {
                        r.RBDPool = c.String(0)
                        if r.RBDPool == "" {
                                r.RBDPool = "rbd"
                        }
                        r.RadosUser = c.String(0)
                        if r.RadosUser == "" {
                                r.RadosUser = "admin"
                        }
                        r.Keyring = c.String(0)
                        if r.Keyring == "" {
                                r.Keyring = "/etc/ceph/keyring"
                        }
                },
                func(r *core.RBDPersistentVolumeSource, c randfill.Continue) {
                        r.RBDPool = c.String(0)
                        if r.RBDPool == "" {
                                r.RBDPool = "rbd"
                        }
                        r.RadosUser = c.String(0)
                        if r.RadosUser == "" {
                                r.RadosUser = "admin"
                        }
                        r.Keyring = c.String(0)
                        if r.Keyring == "" {
                                r.Keyring = "/etc/ceph/keyring"
                        }
                },
                func(obj *core.HostPathVolumeSource, c randfill.Continue) {
                        c.FillNoCustom(obj)
                        types := []core.HostPathType{core.HostPathUnset, core.HostPathDirectoryOrCreate, core.HostPathDirectory,
                                core.HostPathFileOrCreate, core.HostPathFile, core.HostPathSocket, core.HostPathCharDev, core.HostPathBlockDev}
                        typeVol := types[c.Rand.Intn(len(types))]
                        if obj.Type == nil {
                                obj.Type = &typeVol
                        }
                },
                func(pv *core.PersistentVolume, c randfill.Continue) {
                        c.FillNoCustom(pv) // fuzz self without calling this function again
                        types := []core.PersistentVolumePhase{core.VolumeAvailable, core.VolumePending, core.VolumeBound, core.VolumeReleased, core.VolumeFailed}
                        pv.Status.Phase = types[c.Rand.Intn(len(types))]
                        pv.Status.Message = c.String(0)
                        reclamationPolicies := []core.PersistentVolumeReclaimPolicy{core.PersistentVolumeReclaimRecycle, core.PersistentVolumeReclaimRetain}
                        pv.Spec.PersistentVolumeReclaimPolicy = reclamationPolicies[c.Rand.Intn(len(reclamationPolicies))]
                        volumeModes := []core.PersistentVolumeMode{core.PersistentVolumeFilesystem, core.PersistentVolumeBlock}
                        pv.Spec.VolumeMode = &volumeModes[c.Rand.Intn(len(volumeModes))]
                },
                func(pvc *core.PersistentVolumeClaim, c randfill.Continue) {
                        c.FillNoCustom(pvc) // fuzz self without calling this function again
                        types := []core.PersistentVolumeClaimPhase{core.ClaimBound, core.ClaimPending, core.ClaimLost}
                        pvc.Status.Phase = types[c.Rand.Intn(len(types))]
                        volumeModes := []core.PersistentVolumeMode{core.PersistentVolumeFilesystem, core.PersistentVolumeBlock}
                        pvc.Spec.VolumeMode = &volumeModes[c.Rand.Intn(len(volumeModes))]
                },
                func(obj *core.AzureDiskVolumeSource, c randfill.Continue) {
                        if obj.CachingMode == nil {
                                obj.CachingMode = new(core.AzureDataDiskCachingMode)
                                *obj.CachingMode = core.AzureDataDiskCachingReadWrite
                        }
                        if obj.Kind == nil {
                                obj.Kind = new(core.AzureDataDiskKind)
                                *obj.Kind = core.AzureSharedBlobDisk
                        }
                        if obj.FSType == nil {
                                obj.FSType = new(string)
                                *obj.FSType = "ext4"
                        }
                        if obj.ReadOnly == nil {
                                obj.ReadOnly = new(bool)
                                *obj.ReadOnly = false
                        }
                },
                func(sio *core.ScaleIOVolumeSource, c randfill.Continue) {
                        sio.StorageMode = c.String(0)
                        if sio.StorageMode == "" {
                                sio.StorageMode = "ThinProvisioned"
                        }
                        sio.FSType = c.String(0)
                        if sio.FSType == "" {
                                sio.FSType = "xfs"
                        }
                },
                func(sio *core.ScaleIOPersistentVolumeSource, c randfill.Continue) {
                        sio.StorageMode = c.String(0)
                        if sio.StorageMode == "" {
                                sio.StorageMode = "ThinProvisioned"
                        }
                        sio.FSType = c.String(0)
                        if sio.FSType == "" {
                                sio.FSType = "xfs"
                        }
                },
                func(s *core.NamespaceSpec, c randfill.Continue) {
                        s.Finalizers = []core.FinalizerName{core.FinalizerKubernetes}
                },
                func(s *core.Namespace, c randfill.Continue) {
                        c.FillNoCustom(s) // fuzz self without calling this function again
                        // Match name --> label defaulting
                        if len(s.Name) > 0 {
                                if s.Labels == nil {
                                        s.Labels = map[string]string{}
                                }
                                s.Labels["kubernetes.io/metadata.name"] = s.Name
                        }
                },
                func(s *core.NamespaceStatus, c randfill.Continue) {
                        s.Phase = core.NamespaceActive
                },
                func(http *core.HTTPGetAction, c randfill.Continue) {
                        c.FillNoCustom(http)            // fuzz self without calling this function again
                        http.Path = "/" + http.Path     // can't be blank
                        http.Scheme = "x" + http.Scheme // can't be blank
                },
                func(ss *core.ServiceSpec, c randfill.Continue) {
                        c.FillNoCustom(ss) // fuzz self without calling this function again
                        if len(ss.Ports) == 0 {
                                // There must be at least 1 port.
                                ss.Ports = append(ss.Ports, core.ServicePort{})
                                c.Fill(&ss.Ports[0])
                        }
                        for i := range ss.Ports {
                                switch ss.Ports[i].TargetPort.Type {
                                case intstr.Int:
                                        ss.Ports[i].TargetPort.IntVal = 1 + ss.Ports[i].TargetPort.IntVal%65535 // non-zero
                                case intstr.String:
                                        ss.Ports[i].TargetPort.StrVal = "x" + ss.Ports[i].TargetPort.StrVal // non-empty
                                }
                        }
                        types := []core.ServiceAffinity{core.ServiceAffinityNone, core.ServiceAffinityClientIP}
                        ss.SessionAffinity = types[c.Rand.Intn(len(types))]
                        switch ss.SessionAffinity {
                        case core.ServiceAffinityClientIP:
                                timeoutSeconds := int32(c.Rand.Intn(int(core.MaxClientIPServiceAffinitySeconds)))
                                ss.SessionAffinityConfig = &core.SessionAffinityConfig{
                                        ClientIP: &core.ClientIPConfig{
                                                TimeoutSeconds: &timeoutSeconds,
                                        },
                                }
                        case core.ServiceAffinityNone:
                                ss.SessionAffinityConfig = nil
                        }
                        if ss.AllocateLoadBalancerNodePorts == nil {
                                ss.AllocateLoadBalancerNodePorts = ptr.To(true)
                        }
                },
                func(s *core.NodeStatus, c randfill.Continue) {
                        c.FillNoCustom(s)
                        s.Allocatable = s.Capacity
                },
                func(e *core.Event, c randfill.Continue) {
                        c.FillNoCustom(e)
                        e.EventTime = metav1.MicroTime{Time: time.Unix(1, 1000)}
                        if e.Series != nil {
                                e.Series.LastObservedTime = metav1.MicroTime{Time: time.Unix(3, 3000)}
                        }
                },
                func(j *core.GRPCAction, c randfill.Continue) {
                        empty := ""
                        if j.Service == nil {
                                j.Service = &empty
                        }
                },
                func(j *core.LoadBalancerStatus, c randfill.Continue) {
                        ipMode := core.LoadBalancerIPModeVIP
                        for i := range j.Ingress {
                                if j.Ingress[i].IPMode == nil {
                                        j.Ingress[i].IPMode = &ipMode
                                }
                        }
                },
        }
}

/*
Copyright 2014 The Kubernetes Authors.

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.
*/

package helper

import (
        "encoding/json"
        "fmt"
        "strconv"
        "strings"

        "k8s.io/apimachinery/pkg/api/resource"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/fields"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/apimachinery/pkg/util/sets"
        "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/kubernetes/pkg/apis/core"
)

// IsHugePageResourceName returns true if the resource name has the huge page
// resource prefix.
func IsHugePageResourceName(name core.ResourceName) bool {
        return strings.HasPrefix(string(name), core.ResourceHugePagesPrefix)
}

// IsHugePageResourceValueDivisible returns true if the resource value of storage is
// integer multiple of page size.
func IsHugePageResourceValueDivisible(name core.ResourceName, quantity resource.Quantity) bool {
        pageSize, err := HugePageSizeFromResourceName(name)
        if err != nil {
                return false
        }

        if pageSize.Sign() <= 0 || pageSize.MilliValue()%int64(1000) != int64(0) {
                return false
        }

        return quantity.Value()%pageSize.Value() == 0
}

// IsQuotaHugePageResourceName returns true if the resource name has the quota
// related huge page resource prefix.
func IsQuotaHugePageResourceName(name core.ResourceName) bool {
        return strings.HasPrefix(string(name), core.ResourceHugePagesPrefix) || strings.HasPrefix(string(name), core.ResourceRequestsHugePagesPrefix)
}

// HugePageResourceName returns a ResourceName with the canonical hugepage
// prefix prepended for the specified page size.  The page size is converted
// to its canonical representation.
func HugePageResourceName(pageSize resource.Quantity) core.ResourceName {
        return core.ResourceName(fmt.Sprintf("%s%s", core.ResourceHugePagesPrefix, pageSize.String()))
}

// HugePageSizeFromResourceName returns the page size for the specified huge page
// resource name.  If the specified input is not a valid huge page resource name
// an error is returned.
func HugePageSizeFromResourceName(name core.ResourceName) (resource.Quantity, error) {
        if !IsHugePageResourceName(name) {
                return resource.Quantity{}, fmt.Errorf("resource name: %s is an invalid hugepage name", name)
        }
        pageSize := strings.TrimPrefix(string(name), core.ResourceHugePagesPrefix)
        return resource.ParseQuantity(pageSize)
}

// NonConvertibleFields iterates over the provided map and filters out all but
// any keys with the "non-convertible.kubernetes.io" prefix.
func NonConvertibleFields(annotations map[string]string) map[string]string {
        nonConvertibleKeys := map[string]string{}
        for key, value := range annotations {
                if strings.HasPrefix(key, core.NonConvertibleAnnotationPrefix) {
                        nonConvertibleKeys[key] = value
                }
        }
        return nonConvertibleKeys
}

// Semantic can do semantic deep equality checks for core objects.
// Example: apiequality.Semantic.DeepEqual(aPod, aPodWithNonNilButEmptyMaps) == true
var Semantic = conversion.EqualitiesOrDie(
        func(a, b resource.Quantity) bool {
                // Ignore formatting, only care that numeric value stayed the same.
                // TODO: if we decide it's important, it should be safe to start comparing the format.
                //
                // Uninitialized quantities are equivalent to 0 quantities.
                return a.Cmp(b) == 0
        },
        func(a, b metav1.MicroTime) bool {
                return a.UTC() == b.UTC()
        },
        func(a, b metav1.Time) bool {
                return a.UTC() == b.UTC()
        },
        func(a, b labels.Selector) bool {
                return a.String() == b.String()
        },
        func(a, b fields.Selector) bool {
                return a.String() == b.String()
        },
)

var standardResourceQuotaScopes = sets.New(
        core.ResourceQuotaScopeTerminating,
        core.ResourceQuotaScopeNotTerminating,
        core.ResourceQuotaScopeBestEffort,
        core.ResourceQuotaScopeNotBestEffort,
        core.ResourceQuotaScopePriorityClass,
        core.ResourceQuotaScopeVolumeAttributesClass,
)

// IsStandardResourceQuotaScope returns true if the scope is a standard value
func IsStandardResourceQuotaScope(scope core.ResourceQuotaScope) bool {
        return standardResourceQuotaScopes.Has(scope) || scope == core.ResourceQuotaScopeCrossNamespacePodAffinity
}

var podObjectCountQuotaResources = sets.New(
        core.ResourcePods,
)

var podComputeQuotaResources = sets.New(
        core.ResourceCPU,
        core.ResourceMemory,
        core.ResourceLimitsCPU,
        core.ResourceLimitsMemory,
        core.ResourceRequestsCPU,
        core.ResourceRequestsMemory,
)

var pvcObjectCountQuotaResources = sets.New(
        core.ResourcePersistentVolumeClaims,
)

var pvcStorageQuotaResources = sets.New(
        core.ResourceRequestsStorage,
)

// IsResourceQuotaScopeValidForResource returns true if the resource applies to the specified scope
func IsResourceQuotaScopeValidForResource(scope core.ResourceQuotaScope, resource core.ResourceName) bool {
        switch scope {
        case core.ResourceQuotaScopeTerminating, core.ResourceQuotaScopeNotTerminating, core.ResourceQuotaScopeNotBestEffort,
                core.ResourceQuotaScopePriorityClass, core.ResourceQuotaScopeCrossNamespacePodAffinity:
                return podObjectCountQuotaResources.Has(resource) || podComputeQuotaResources.Has(resource)
        case core.ResourceQuotaScopeBestEffort:
                return podObjectCountQuotaResources.Has(resource)
        case core.ResourceQuotaScopeVolumeAttributesClass:
                return pvcObjectCountQuotaResources.Has(resource) || pvcStorageQuotaResources.Has(resource)
        default:
                return true
        }
}

var standardContainerResources = sets.New(
        core.ResourceCPU,
        core.ResourceMemory,
        core.ResourceEphemeralStorage,
)

// IsStandardContainerResourceName returns true if the container can make a resource request
// for the specified resource
func IsStandardContainerResourceName(name core.ResourceName) bool {
        return standardContainerResources.Has(name) || IsHugePageResourceName(name)
}

// IsExtendedResourceName returns true if:
// 1. the resource name is not in the default namespace;
// 2. resource name does not have "requests." prefix,
// to avoid confusion with the convention in quota
// 3. it satisfies the rules in IsQualifiedName() after converted into quota resource name
func IsExtendedResourceName(name core.ResourceName) bool {
        if IsNativeResource(name) || strings.HasPrefix(string(name), core.DefaultResourceRequestsPrefix) {
                return false
        }
        // Ensure it satisfies the rules in IsQualifiedName() after converted into quota resource name
        nameForQuota := fmt.Sprintf("%s%s", core.DefaultResourceRequestsPrefix, string(name))
        if errs := validation.IsQualifiedName(nameForQuota); len(errs) != 0 {
                return false
        }
        return true
}

// IsNativeResource returns true if the resource name is in the
// *kubernetes.io/ namespace. Partially-qualified (unprefixed) names are
// implicitly in the kubernetes.io/ namespace.
func IsNativeResource(name core.ResourceName) bool {
        return !strings.Contains(string(name), "/") ||
                strings.Contains(string(name), core.ResourceDefaultNamespacePrefix)
}

// IsOvercommitAllowed returns true if the resource is in the default
// namespace and is not hugepages.
func IsOvercommitAllowed(name core.ResourceName) bool {
        return IsNativeResource(name) &&
                !IsHugePageResourceName(name)
}

var standardLimitRangeTypes = sets.New(
        core.LimitTypePod,
        core.LimitTypeContainer,
        core.LimitTypePersistentVolumeClaim,
)

// IsStandardLimitRangeType returns true if the type is Pod or Container
func IsStandardLimitRangeType(value core.LimitType) bool {
        return standardLimitRangeTypes.Has(value)
}

var standardQuotaResources = sets.New(
        core.ResourceCPU,
        core.ResourceMemory,
        core.ResourceEphemeralStorage,
        core.ResourceRequestsCPU,
        core.ResourceRequestsMemory,
        core.ResourceRequestsStorage,
        core.ResourceRequestsEphemeralStorage,
        core.ResourceLimitsCPU,
        core.ResourceLimitsMemory,
        core.ResourceLimitsEphemeralStorage,
        core.ResourcePods,
        core.ResourceQuotas,
        core.ResourceServices,
        core.ResourceReplicationControllers,
        core.ResourceSecrets,
        core.ResourcePersistentVolumeClaims,
        core.ResourceConfigMaps,
        core.ResourceServicesNodePorts,
        core.ResourceServicesLoadBalancers,
)

// IsStandardQuotaResourceName returns true if the resource is known to
// the quota tracking system
func IsStandardQuotaResourceName(name core.ResourceName) bool {
        return standardQuotaResources.Has(name) || IsQuotaHugePageResourceName(name)
}

var standardResources = sets.New(
        core.ResourceCPU,
        core.ResourceMemory,
        core.ResourceEphemeralStorage,
        core.ResourceRequestsCPU,
        core.ResourceRequestsMemory,
        core.ResourceRequestsEphemeralStorage,
        core.ResourceLimitsCPU,
        core.ResourceLimitsMemory,
        core.ResourceLimitsEphemeralStorage,
        core.ResourcePods,
        core.ResourceQuotas,
        core.ResourceServices,
        core.ResourceReplicationControllers,
        core.ResourceSecrets,
        core.ResourceConfigMaps,
        core.ResourcePersistentVolumeClaims,
        core.ResourceStorage,
        core.ResourceRequestsStorage,
        core.ResourceServicesNodePorts,
        core.ResourceServicesLoadBalancers,
)

// IsStandardResourceName returns true if the resource is known to the system
func IsStandardResourceName(name core.ResourceName) bool {
        return standardResources.Has(name) || IsQuotaHugePageResourceName(name)
}

var integerResources = sets.New(
        core.ResourcePods,
        core.ResourceQuotas,
        core.ResourceServices,
        core.ResourceReplicationControllers,
        core.ResourceSecrets,
        core.ResourceConfigMaps,
        core.ResourcePersistentVolumeClaims,
        core.ResourceServicesNodePorts,
        core.ResourceServicesLoadBalancers,
)

// IsIntegerResourceName returns true if the resource is measured in integer values
func IsIntegerResourceName(name core.ResourceName) bool {
        return integerResources.Has(name) || IsExtendedResourceName(name)
}

// IsServiceIPSet aims to check if the service's ClusterIP is set or not
// the objective is not to perform validation here
func IsServiceIPSet(service *core.Service) bool {
        // This function assumes that the service is semantically validated
        // it does not test if the IP is valid, just makes sure that it is set.
        return len(service.Spec.ClusterIP) > 0 &&
                service.Spec.ClusterIP != core.ClusterIPNone
}

var standardFinalizers = sets.New(
        string(core.FinalizerKubernetes),
        metav1.FinalizerOrphanDependents,
        metav1.FinalizerDeleteDependents,
)

// IsStandardFinalizerName checks if the input string is a standard finalizer name
func IsStandardFinalizerName(str string) bool {
        return standardFinalizers.Has(str)
}

// GetAccessModesAsString returns a string representation of an array of access modes.
// modes, when present, are always in the same order: RWO,ROX,RWX,RWOP.
func GetAccessModesAsString(modes []core.PersistentVolumeAccessMode) string {
        modes = removeDuplicateAccessModes(modes)
        modesStr := []string{}
        if ContainsAccessMode(modes, core.ReadWriteOnce) {
                modesStr = append(modesStr, "RWO")
        }
        if ContainsAccessMode(modes, core.ReadOnlyMany) {
                modesStr = append(modesStr, "ROX")
        }
        if ContainsAccessMode(modes, core.ReadWriteMany) {
                modesStr = append(modesStr, "RWX")
        }
        if ContainsAccessMode(modes, core.ReadWriteOncePod) {
                modesStr = append(modesStr, "RWOP")
        }
        return strings.Join(modesStr, ",")
}

// GetAccessModesFromString returns an array of AccessModes from a string created by GetAccessModesAsString
func GetAccessModesFromString(modes string) []core.PersistentVolumeAccessMode {
        strmodes := strings.Split(modes, ",")
        accessModes := []core.PersistentVolumeAccessMode{}
        for _, s := range strmodes {
                s = strings.Trim(s, " ")
                switch {
                case s == "RWO":
                        accessModes = append(accessModes, core.ReadWriteOnce)
                case s == "ROX":
                        accessModes = append(accessModes, core.ReadOnlyMany)
                case s == "RWX":
                        accessModes = append(accessModes, core.ReadWriteMany)
                case s == "RWOP":
                        accessModes = append(accessModes, core.ReadWriteOncePod)
                }
        }
        return accessModes
}

// removeDuplicateAccessModes returns an array of access modes without any duplicates
func removeDuplicateAccessModes(modes []core.PersistentVolumeAccessMode) []core.PersistentVolumeAccessMode {
        accessModes := []core.PersistentVolumeAccessMode{}
        for _, m := range modes {
                if !ContainsAccessMode(accessModes, m) {
                        accessModes = append(accessModes, m)
                }
        }
        return accessModes
}

func ContainsAccessMode(modes []core.PersistentVolumeAccessMode, mode core.PersistentVolumeAccessMode) bool {
        for _, m := range modes {
                if m == mode {
                        return true
                }
        }
        return false
}

func ClaimContainsAllocatedResources(pvc *core.PersistentVolumeClaim) bool {
        if pvc == nil {
                return false
        }

        if pvc.Status.AllocatedResources != nil {
                return true
        }
        return false
}

func ClaimContainsAllocatedResourceStatus(pvc *core.PersistentVolumeClaim) bool {
        if pvc == nil {
                return false
        }

        if pvc.Status.AllocatedResourceStatuses != nil {
                return true
        }
        return false
}

// GetTolerationsFromPodAnnotations gets the json serialized tolerations data from Pod.Annotations
// and converts it to the []Toleration type in core.
func GetTolerationsFromPodAnnotations(annotations map[string]string) ([]core.Toleration, error) {
        var tolerations []core.Toleration
        if len(annotations) > 0 && annotations[core.TolerationsAnnotationKey] != "" {
                err := json.Unmarshal([]byte(annotations[core.TolerationsAnnotationKey]), &tolerations)
                if err != nil {
                        return tolerations, err
                }
        }
        return tolerations, nil
}

// AddOrUpdateTolerationInPod tries to add a toleration to the pod's toleration list.
// Returns true if something was updated, false otherwise.
func AddOrUpdateTolerationInPod(pod *core.Pod, toleration *core.Toleration) bool {
        podTolerations := pod.Spec.Tolerations

        var newTolerations []core.Toleration
        updated := false
        for i := range podTolerations {
                if toleration.MatchToleration(&podTolerations[i]) {
                        if Semantic.DeepEqual(toleration, podTolerations[i]) {
                                return false
                        }
                        newTolerations = append(newTolerations, *toleration)
                        updated = true
                        continue
                }

                newTolerations = append(newTolerations, podTolerations[i])
        }

        if !updated {
                newTolerations = append(newTolerations, *toleration)
        }

        pod.Spec.Tolerations = newTolerations
        return true
}

// GetTaintsFromNodeAnnotations gets the json serialized taints data from Pod.Annotations
// and converts it to the []Taint type in core.
func GetTaintsFromNodeAnnotations(annotations map[string]string) ([]core.Taint, error) {
        var taints []core.Taint
        if len(annotations) > 0 && annotations[core.TaintsAnnotationKey] != "" {
                err := json.Unmarshal([]byte(annotations[core.TaintsAnnotationKey]), &taints)
                if err != nil {
                        return []core.Taint{}, err
                }
        }
        return taints, nil
}

// GetPersistentVolumeClass returns StorageClassName.
func GetPersistentVolumeClass(volume *core.PersistentVolume) string {
        // Use beta annotation first
        if class, found := volume.Annotations[core.BetaStorageClassAnnotation]; found {
                return class
        }

        return volume.Spec.StorageClassName
}

// GetPersistentVolumeClaimClass returns StorageClassName. If no storage class was
// requested, it returns "".
func GetPersistentVolumeClaimClass(claim *core.PersistentVolumeClaim) string {
        // Use beta annotation first
        if class, found := claim.Annotations[core.BetaStorageClassAnnotation]; found {
                return class
        }

        if claim.Spec.StorageClassName != nil {
                return *claim.Spec.StorageClassName
        }

        return ""
}

// PersistentVolumeClaimHasClass returns true if given claim has set StorageClassName field.
func PersistentVolumeClaimHasClass(claim *core.PersistentVolumeClaim) bool {
        // Use beta annotation first
        if _, found := claim.Annotations[core.BetaStorageClassAnnotation]; found {
                return true
        }

        if claim.Spec.StorageClassName != nil {
                return true
        }

        return false
}

// GetDeletionCostFromPodAnnotations returns the integer value of pod-deletion-cost. Returns 0
// if not set or the value is invalid.
func GetDeletionCostFromPodAnnotations(annotations map[string]string) (int32, error) {
        if value, exist := annotations[core.PodDeletionCost]; exist {
                // values that start with plus sign (e.g, "+10") or leading zeros (e.g., "008") are not valid.
                if !validFirstDigit(value) {
                        return 0, fmt.Errorf("invalid value %q", value)
                }

                i, err := strconv.ParseInt(value, 10, 32)
                if err != nil {
                        // make sure we default to 0 on error.
                        return 0, err
                }
                return int32(i), nil
        }
        return 0, nil
}

func validFirstDigit(str string) bool {
        if len(str) == 0 {
                return false
        }
        return str[0] == '-' || (str[0] == '0' && str == "0") || (str[0] >= '1' && str[0] <= '9')
}

// HasInvalidLabelValueInNodeSelectorTerms checks if there's an invalid label value
// in one NodeSelectorTerm's MatchExpression values
func HasInvalidLabelValueInNodeSelectorTerms(terms []core.NodeSelectorTerm) bool {
        for _, term := range terms {
                for _, expression := range term.MatchExpressions {
                        for _, value := range expression.Values {
                                if len(validation.IsValidLabelValue(value)) > 0 {
                                        return true
                                }
                        }
                }
        }
        return false
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

// NOTE: DO NOT use those helper functions through client-go, the
// package path will be changed in the future.
package qos

import (
        "k8s.io/apimachinery/pkg/api/resource"
        "k8s.io/apimachinery/pkg/util/sets"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/features"
)

var supportedQoSComputeResources = sets.NewString(string(core.ResourceCPU), string(core.ResourceMemory))

func isSupportedQoSComputeResource(name core.ResourceName) bool {
        return supportedQoSComputeResources.Has(string(name))
}

// GetPodQOS returns the QoS class of a pod persisted in the PodStatus.QOSClass field.
// If PodStatus.QOSClass is empty, it returns value of ComputePodQOS() which evaluates pod's QoS class.
func GetPodQOS(pod *core.Pod) core.PodQOSClass {
        if pod.Status.QOSClass != "" {
                return pod.Status.QOSClass
        }
        return ComputePodQOS(pod)
}

// zeroQuantity represents a resource.Quantity with value "0", used as a baseline
// for resource comparisons.
var zeroQuantity = resource.MustParse("0")

// processResourceList adds non-zero quantities for supported QoS compute resources
// quantities from newList to list.
func processResourceList(list, newList core.ResourceList) {
        for name, quantity := range newList {
                if !isSupportedQoSComputeResource(name) {
                        continue
                }
                if quantity.Cmp(zeroQuantity) == 1 {
                        delta := quantity.DeepCopy()
                        if _, exists := list[name]; !exists {
                                list[name] = delta
                        } else {
                                delta.Add(list[name])
                                list[name] = delta
                        }
                }
        }
}

// getQOSResources returns a set of resource names from the provided resource list that:
// 1. Are supported QoS compute resources
// 2. Have quantities greater than zero
func getQOSResources(list core.ResourceList) sets.Set[string] {
        qosResources := sets.New[string]()
        for name, quantity := range list {
                if !isSupportedQoSComputeResource(name) {
                        continue
                }
                if quantity.Cmp(zeroQuantity) == 1 {
                        qosResources.Insert(string(name))
                }
        }
        return qosResources
}

// ComputePodQOS evaluates the list of containers to determine a pod's QoS class. This function is more
// expensive than GetPodQOS which should be used for pods having a non-empty .Status.QOSClass.
// A pod is besteffort if none of its containers have specified any requests or limits.
// A pod is guaranteed only when requests and limits are specified for all the containers and they are equal.
// A pod is burstable if limits and requests do not match across all containers.
// When this function is updated please also update staging/src/k8s.io/kubectl/pkg/util/qos/qos.go
func ComputePodQOS(pod *core.Pod) core.PodQOSClass {
        requests := core.ResourceList{}
        limits := core.ResourceList{}
        isGuaranteed := true
        // When pod-level resources are specified, we use them to determine QoS class.
        if utilfeature.DefaultFeatureGate.Enabled(features.PodLevelResources) &&
                pod.Spec.Resources != nil {
                if len(pod.Spec.Resources.Requests) > 0 {
                        // process requests
                        processResourceList(requests, pod.Spec.Resources.Requests)
                }

                if len(pod.Spec.Resources.Limits) > 0 {
                        // process limits
                        processResourceList(limits, pod.Spec.Resources.Limits)
                        qosLimitResources := getQOSResources(pod.Spec.Resources.Limits)
                        if !qosLimitResources.HasAll(string(core.ResourceMemory), string(core.ResourceCPU)) {
                                isGuaranteed = false
                        }
                }
        } else {
                // note, ephemeral containers are not considered for QoS as they cannot define resources
                allContainers := []core.Container{}
                allContainers = append(allContainers, pod.Spec.Containers...)
                allContainers = append(allContainers, pod.Spec.InitContainers...)
                for _, container := range allContainers {
                        // process requests
                        for name, quantity := range container.Resources.Requests {
                                if !isSupportedQoSComputeResource(name) {
                                        continue
                                }
                                if quantity.Cmp(zeroQuantity) == 1 {
                                        delta := quantity.DeepCopy()
                                        if _, exists := requests[name]; !exists {
                                                requests[name] = delta
                                        } else {
                                                delta.Add(requests[name])
                                                requests[name] = delta
                                        }
                                }
                        }
                        // process limits
                        qosLimitsFound := sets.NewString()
                        for name, quantity := range container.Resources.Limits {
                                if !isSupportedQoSComputeResource(name) {
                                        continue
                                }
                                if quantity.Cmp(zeroQuantity) == 1 {
                                        qosLimitsFound.Insert(string(name))
                                        delta := quantity.DeepCopy()
                                        if _, exists := limits[name]; !exists {
                                                limits[name] = delta
                                        } else {
                                                delta.Add(limits[name])
                                                limits[name] = delta
                                        }
                                }
                        }

                        if !qosLimitsFound.HasAll(string(core.ResourceMemory), string(core.ResourceCPU)) {
                                isGuaranteed = false
                        }
                }
        }

        if len(requests) == 0 && len(limits) == 0 {
                return core.PodQOSBestEffort
        }
        // Check if requests match limits for all resources.
        if isGuaranteed {
                for name, req := range requests {
                        if lim, exists := limits[name]; !exists || lim.Cmp(req) != 0 {
                                isGuaranteed = false
                                break
                        }
                }
        }
        if isGuaranteed &&
                len(requests) == len(limits) {
                return core.PodQOSGuaranteed
        }
        return core.PodQOSBurstable
}

/*
Copyright 2014 The Kubernetes Authors.

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.
*/

// Package install installs the v1 monolithic api, making it available as an
// option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/core/v1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(core.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion))
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package core

import "encoding/json"

// This file implements json marshaling/unmarshaling interfaces on objects that are currently marshaled into annotations
// to prevent anyone from marshaling these internal structs.

var _ = json.Marshaler(&AvoidPods{})
var _ = json.Unmarshaler(&AvoidPods{})

// MarshalJSON panics to prevent marshalling of internal structs
func (AvoidPods) MarshalJSON() ([]byte, error) { panic("do not marshal internal struct") }

// UnmarshalJSON panics to prevent unmarshalling of internal structs
func (*AvoidPods) UnmarshalJSON([]byte) error { panic("do not unmarshal to internal struct") }

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

//TODO: consider making these methods functions, because we don't want helper
//functions in the k8s.io/api repo.

package core

import (
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// SetGroupVersionKind sets the API version and kind of the object reference
func (obj *ObjectReference) SetGroupVersionKind(gvk schema.GroupVersionKind) {
        obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind()
}

// GroupVersionKind returns the API version and kind of the object reference
func (obj *ObjectReference) GroupVersionKind() schema.GroupVersionKind {
        return schema.FromAPIVersionAndKind(obj.APIVersion, obj.Kind)
}

// GetObjectKind returns the kind of object reference
func (obj *ObjectReference) GetObjectKind() schema.ObjectKind { return obj }

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package pods

import (
        "fmt"

        "k8s.io/apimachinery/pkg/util/validation/field"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/fieldpath"
)

// ContainerVisitorWithPath is called with each container and the field.Path to that container,
// and returns true if visiting should continue.
type ContainerVisitorWithPath func(container *api.Container, path *field.Path) bool

// VisitContainersWithPath invokes the visitor function with a pointer to the spec
// of every container in the given pod spec and the field.Path to that container.
// If visitor returns false, visiting is short-circuited. VisitContainersWithPath returns true if visiting completes,
// false if visiting was short-circuited.
func VisitContainersWithPath(podSpec *api.PodSpec, specPath *field.Path, visitor ContainerVisitorWithPath) bool {
        fldPath := specPath.Child("initContainers")
        for i := range podSpec.InitContainers {
                if !visitor(&podSpec.InitContainers[i], fldPath.Index(i)) {
                        return false
                }
        }
        fldPath = specPath.Child("containers")
        for i := range podSpec.Containers {
                if !visitor(&podSpec.Containers[i], fldPath.Index(i)) {
                        return false
                }
        }
        fldPath = specPath.Child("ephemeralContainers")
        for i := range podSpec.EphemeralContainers {
                if !visitor((*api.Container)(&podSpec.EphemeralContainers[i].EphemeralContainerCommon), fldPath.Index(i)) {
                        return false
                }
        }
        return true
}

// ConvertDownwardAPIFieldLabel converts the specified downward API field label
// and its value in the pod of the specified version to the internal version,
// and returns the converted label and value. This function returns an error if
// the conversion fails.
func ConvertDownwardAPIFieldLabel(version, label, value string) (string, string, error) {
        if version != "v1" {
                return "", "", fmt.Errorf("unsupported pod version: %s", version)
        }

        if path, _, ok := fieldpath.SplitMaybeSubscriptedPath(label); ok {
                switch path {
                case "metadata.annotations", "metadata.labels":
                        return label, value, nil
                default:
                        return "", "", fmt.Errorf("field label does not support subscript: %s", label)
                }
        }

        switch label {
        case "metadata.annotations",
                "metadata.labels",
                "metadata.name",
                "metadata.namespace",
                "metadata.uid",
                "spec.nodeName",
                "spec.restartPolicy",
                "spec.serviceAccountName",
                "spec.schedulerName",
                "status.phase",
                "status.hostIP",
                "status.hostIPs",
                "status.podIP",
                "status.podIPs":
                return label, value, nil
        // This is for backwards compatibility with old v1 clients which send spec.host
        case "spec.host":
                return "spec.nodeName", value, nil
        default:
                return "", "", fmt.Errorf("field label not supported: %s", label)
        }
}

/*
Copyright 2014 The Kubernetes Authors.

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.
*/

package core

import (
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = ""

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder object to register various known types
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)

        // AddToScheme represents a func that can be used to apply all the registered
        // funcs in a scheme
        AddToScheme = SchemeBuilder.AddToScheme
)

func addKnownTypes(scheme *runtime.Scheme) error {
        if err := scheme.AddIgnoredConversionType(&metav1.TypeMeta{}, &metav1.TypeMeta{}); err != nil {
                return err
        }
        scheme.AddKnownTypes(SchemeGroupVersion,
                &Pod{},
                &PodList{},
                &PodStatusResult{},
                &PodTemplate{},
                &PodTemplateList{},
                &ReplicationControllerList{},
                &ReplicationController{},
                &ServiceList{},
                &Service{},
                &ServiceProxyOptions{},
                &NodeList{},
                &Node{},
                &NodeProxyOptions{},
                &Endpoints{},
                &EndpointsList{},
                &Binding{},
                &Event{},
                &EventList{},
                &List{},
                &LimitRange{},
                &LimitRangeList{},
                &ResourceQuota{},
                &ResourceQuotaList{},
                &Namespace{},
                &NamespaceList{},
                &ServiceAccount{},
                &ServiceAccountList{},
                &Secret{},
                &SecretList{},
                &PersistentVolume{},
                &PersistentVolumeList{},
                &PersistentVolumeClaim{},
                &PersistentVolumeClaimList{},
                &PodAttachOptions{},
                &PodLogOptions{},
                &PodExecOptions{},
                &PodPortForwardOptions{},
                &PodProxyOptions{},
                &ComponentStatus{},
                &ComponentStatusList{},
                &SerializedReference{},
                &RangeAllocation{},
                &ConfigMap{},
                &ConfigMapList{},
        )

        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package core

import (
        "k8s.io/apimachinery/pkg/api/resource"
)

func (rn ResourceName) String() string {
        return string(rn)
}

// CPU returns the CPU limit if specified.
func (rl *ResourceList) CPU() *resource.Quantity {
        return rl.Name(ResourceCPU, resource.DecimalSI)
}

// Memory returns the Memory limit if specified.
func (rl *ResourceList) Memory() *resource.Quantity {
        return rl.Name(ResourceMemory, resource.BinarySI)
}

// Storage returns the Storage limit if specified.
func (rl *ResourceList) Storage() *resource.Quantity {
        return rl.Name(ResourceStorage, resource.BinarySI)
}

// Pods returns the list of pods
func (rl *ResourceList) Pods() *resource.Quantity {
        return rl.Name(ResourcePods, resource.DecimalSI)
}

// StorageEphemeral returns the list of ephemeral storage volumes, if any
func (rl *ResourceList) StorageEphemeral() *resource.Quantity {
        return rl.Name(ResourceEphemeralStorage, resource.BinarySI)
}

// Name returns the resource with name if specified, otherwise it returns a nil quantity with default format.
func (rl *ResourceList) Name(name ResourceName, defaultFormat resource.Format) *resource.Quantity {
        if val, ok := (*rl)[name]; ok {
                return &val
        }
        return &resource.Quantity{Format: defaultFormat}
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

//TODO: consider making these methods functions, because we don't want helper
//functions in the k8s.io/api repo.

package core

import "fmt"

// MatchTaint checks if the taint matches taintToMatch. Taints are unique by key:effect,
// if the two taints have same key:effect, regard as they match.
func (t *Taint) MatchTaint(taintToMatch Taint) bool {
        return t.Key == taintToMatch.Key && t.Effect == taintToMatch.Effect
}

// ToString converts taint struct to string in format '<key>=<value>:<effect>', '<key>=<value>:', '<key>:<effect>', or '<key>'.
func (t *Taint) ToString() string {
        if len(t.Effect) == 0 {
                if len(t.Value) == 0 {
                        return fmt.Sprintf("%v", t.Key)
                }
                return fmt.Sprintf("%v=%v:", t.Key, t.Value)
        }
        if len(t.Value) == 0 {
                return fmt.Sprintf("%v:%v", t.Key, t.Effect)
        }
        return fmt.Sprintf("%v=%v:%v", t.Key, t.Value, t.Effect)
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

//TODO: consider making these methods functions, because we don't want helper
//functions in the k8s.io/api repo.

package core

// MatchToleration checks if the toleration matches tolerationToMatch. Tolerations are unique by <key,effect,operator,value>,
// if the two tolerations have same <key,effect,operator,value> combination, regard as they match.
// TODO: uniqueness check for tolerations in api validations.
func (t *Toleration) MatchToleration(tolerationToMatch *Toleration) bool {
        return t.Key == tolerationToMatch.Key &&
                t.Effect == tolerationToMatch.Effect &&
                t.Operator == tolerationToMatch.Operator &&
                t.Value == tolerationToMatch.Value
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1

import (
        "fmt"
        "reflect"

        "k8s.io/utils/ptr"

        v1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/util/validation/field"
        "k8s.io/kubernetes/pkg/apis/apps"
        "k8s.io/kubernetes/pkg/apis/core"
)

func addConversionFuncs(scheme *runtime.Scheme) error {
        // Add field conversion funcs.
        err := scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Pod"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name",
                                "metadata.namespace",
                                "spec.nodeName",
                                "spec.restartPolicy",
                                "spec.schedulerName",
                                "spec.serviceAccountName",
                                "spec.hostNetwork",
                                "status.phase",
                                "status.podIP",
                                "status.podIPs",
                                "status.nominatedNodeName":
                                return label, value, nil
                        // This is for backwards compatibility with old v1 clients which send spec.host
                        case "spec.host":
                                return "spec.nodeName", value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                },
        )
        if err != nil {
                return err
        }
        err = scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Node"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name":
                                return label, value, nil
                        case "spec.unschedulable":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                },
        )
        if err != nil {
                return err
        }
        err = scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("ReplicationController"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.name",
                                "metadata.namespace",
                                "status.replicas":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                })
        if err != nil {
                return err
        }
        if err := AddFieldLabelConversionsForEvent(scheme); err != nil {
                return err
        }
        if err := AddFieldLabelConversionsForNamespace(scheme); err != nil {
                return err
        }
        if err := AddFieldLabelConversionsForSecret(scheme); err != nil {
                return err
        }
        if err := AddFieldLabelConversionsForService(scheme); err != nil {
                return err
        }
        return nil
}

func Convert_v1_ReplicationController_To_apps_ReplicaSet(in *v1.ReplicationController, out *apps.ReplicaSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ReplicationControllerSpec_To_apps_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_ReplicationControllerStatus_To_apps_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func Convert_v1_ReplicationControllerSpec_To_apps_ReplicaSetSpec(in *v1.ReplicationControllerSpec, out *apps.ReplicaSetSpec, s conversion.Scope) error {
        out.Replicas = *in.Replicas
        out.MinReadySeconds = in.MinReadySeconds
        if in.Selector != nil {
                out.Selector = new(metav1.LabelSelector)
                metav1.Convert_Map_string_To_string_To_v1_LabelSelector(&in.Selector, out.Selector, s)
        }
        if in.Template != nil {
                if err := Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(in.Template, &out.Template, s); err != nil {
                        return err
                }
        }
        return nil
}

func Convert_v1_ReplicationControllerStatus_To_apps_ReplicaSetStatus(in *v1.ReplicationControllerStatus, out *apps.ReplicaSetStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.ObservedGeneration = in.ObservedGeneration
        for _, cond := range in.Conditions {
                out.Conditions = append(out.Conditions, apps.ReplicaSetCondition{
                        Type:               apps.ReplicaSetConditionType(cond.Type),
                        Status:             core.ConditionStatus(cond.Status),
                        LastTransitionTime: cond.LastTransitionTime,
                        Reason:             cond.Reason,
                        Message:            cond.Message,
                })
        }
        return nil
}

func Convert_apps_ReplicaSet_To_v1_ReplicationController(in *apps.ReplicaSet, out *v1.ReplicationController, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_ReplicaSetSpec_To_v1_ReplicationControllerSpec(&in.Spec, &out.Spec, s); err != nil {
                fieldErr, ok := err.(*field.Error)
                if !ok {
                        return err
                }
                if out.Annotations == nil {
                        out.Annotations = make(map[string]string)
                }
                out.Annotations[v1.NonConvertibleAnnotationPrefix+"/"+fieldErr.Field] = reflect.ValueOf(fieldErr.BadValue).String()
        }
        if err := Convert_apps_ReplicaSetStatus_To_v1_ReplicationControllerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func Convert_apps_ReplicaSetSpec_To_v1_ReplicationControllerSpec(in *apps.ReplicaSetSpec, out *v1.ReplicationControllerSpec, s conversion.Scope) error {
        out.Replicas = new(int32)
        *out.Replicas = in.Replicas
        out.MinReadySeconds = in.MinReadySeconds
        var invalidErr error
        if in.Selector != nil {
                invalidErr = metav1.Convert_v1_LabelSelector_To_Map_string_To_string(in.Selector, &out.Selector, s)
        }
        out.Template = new(v1.PodTemplateSpec)
        if err := Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, out.Template, s); err != nil {
                return err
        }
        return invalidErr
}

func Convert_apps_ReplicaSetStatus_To_v1_ReplicationControllerStatus(in *apps.ReplicaSetStatus, out *v1.ReplicationControllerStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.ObservedGeneration = in.ObservedGeneration
        for _, cond := range in.Conditions {
                out.Conditions = append(out.Conditions, v1.ReplicationControllerCondition{
                        Type:               v1.ReplicationControllerConditionType(cond.Type),
                        Status:             v1.ConditionStatus(cond.Status),
                        LastTransitionTime: cond.LastTransitionTime,
                        Reason:             cond.Reason,
                        Message:            cond.Message,
                })
        }
        return nil
}

func Convert_core_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(in *core.ReplicationControllerSpec, out *v1.ReplicationControllerSpec, s conversion.Scope) error {
        if err := autoConvert_core_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(in, out, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = in.Selector
        if in.Template != nil {
                out.Template = new(v1.PodTemplateSpec)
                if err := Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(in.Template, out.Template, s); err != nil {
                        return err
                }
        } else {
                out.Template = nil
        }
        return nil
}

func Convert_v1_ReplicationControllerSpec_To_core_ReplicationControllerSpec(in *v1.ReplicationControllerSpec, out *core.ReplicationControllerSpec, s conversion.Scope) error {
        if err := autoConvert_v1_ReplicationControllerSpec_To_core_ReplicationControllerSpec(in, out, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = in.Selector
        if in.Template != nil {
                out.Template = new(core.PodTemplateSpec)
                if err := Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(in.Template, out.Template, s); err != nil {
                        return err
                }
        } else {
                out.Template = nil
        }
        return nil
}

func Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(in *core.PodTemplateSpec, out *v1.PodTemplateSpec, s conversion.Scope) error {
        if err := autoConvert_core_PodTemplateSpec_To_v1_PodTemplateSpec(in, out, s); err != nil {
                return err
        }

        // drop init container annotations so they don't take effect on legacy kubelets.
        // remove this once the oldest supported kubelet no longer honors the annotations over the field.
        out.Annotations = dropInitContainerAnnotations(out.Annotations)

        return nil
}

func Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(in *v1.PodTemplateSpec, out *core.PodTemplateSpec, s conversion.Scope) error {
        if err := autoConvert_v1_PodTemplateSpec_To_core_PodTemplateSpec(in, out, s); err != nil {
                return err
        }

        // drop init container annotations so they don't show up as differences when receiving requests from old clients
        out.Annotations = dropInitContainerAnnotations(out.Annotations)

        return nil
}

func Convert_v1_PodStatus_To_core_PodStatus(in *v1.PodStatus, out *core.PodStatus, s conversion.Scope) error {
        if err := autoConvert_v1_PodStatus_To_core_PodStatus(in, out, s); err != nil {
                return err
        }

        // If both fields (v1.PodIPs and v1.PodIP) are provided and differ, then PodIP is authoritative for compatibility with older kubelets
        if (len(in.PodIP) > 0 && len(in.PodIPs) > 0) && (in.PodIP != in.PodIPs[0].IP) {
                out.PodIPs = []core.PodIP{
                        {
                                IP: in.PodIP,
                        },
                }
        }
        // at the this point, autoConvert copied v1.PodIPs -> core.PodIPs
        // if v1.PodIPs was empty but v1.PodIP is not, then set core.PodIPs[0] with v1.PodIP
        if len(in.PodIP) > 0 && len(in.PodIPs) == 0 {
                out.PodIPs = []core.PodIP{
                        {
                                IP: in.PodIP,
                        },
                }
        }
        return nil
}

func Convert_core_PodStatus_To_v1_PodStatus(in *core.PodStatus, out *v1.PodStatus, s conversion.Scope) error {
        if err := autoConvert_core_PodStatus_To_v1_PodStatus(in, out, s); err != nil {
                return err
        }
        // at the this point autoConvert copied core.PodIPs -> v1.PodIPs
        //  v1.PodIP (singular value field, which does not exist in core) needs to
        // be set with core.PodIPs[0]
        if len(in.PodIPs) > 0 {
                out.PodIP = in.PodIPs[0].IP
        }
        return nil
}

// The following two v1.PodSpec conversions are done here to support v1.ServiceAccount
// as an alias for ServiceAccountName.
func Convert_core_PodSpec_To_v1_PodSpec(in *core.PodSpec, out *v1.PodSpec, s conversion.Scope) error {
        if err := autoConvert_core_PodSpec_To_v1_PodSpec(in, out, s); err != nil {
                return err
        }

        // DeprecatedServiceAccount is an alias for ServiceAccountName.
        out.DeprecatedServiceAccount = in.ServiceAccountName

        if in.SecurityContext != nil {
                // the host namespace fields have to be handled here for backward compatibility
                // with v1.0.0
                out.HostPID = in.SecurityContext.HostPID
                out.HostNetwork = in.SecurityContext.HostNetwork
                out.HostIPC = in.SecurityContext.HostIPC
                out.ShareProcessNamespace = in.SecurityContext.ShareProcessNamespace
                out.HostUsers = in.SecurityContext.HostUsers
        }

        return nil
}

func Convert_core_NodeSpec_To_v1_NodeSpec(in *core.NodeSpec, out *v1.NodeSpec, s conversion.Scope) error {
        if err := autoConvert_core_NodeSpec_To_v1_NodeSpec(in, out, s); err != nil {
                return err
        }
        // at the this point autoConvert copied core.PodCIDRs -> v1.PodCIDRs
        // v1.PodCIDR (singular value field, which does not exist in core) needs to
        // be set with core.PodCIDRs[0]
        if len(in.PodCIDRs) > 0 {
                out.PodCIDR = in.PodCIDRs[0]
        }
        return nil
}

func Convert_v1_NodeSpec_To_core_NodeSpec(in *v1.NodeSpec, out *core.NodeSpec, s conversion.Scope) error {
        if err := autoConvert_v1_NodeSpec_To_core_NodeSpec(in, out, s); err != nil {
                return err
        }
        // If both fields (v1.PodCIDRs and v1.PodCIDR) are provided and differ, then PodCIDR is authoritative for compatibility with older clients
        if (len(in.PodCIDR) > 0 && len(in.PodCIDRs) > 0) && (in.PodCIDR != in.PodCIDRs[0]) {
                out.PodCIDRs = []string{in.PodCIDR}
        }

        // at the this point, autoConvert copied v1.PodCIDRs -> core.PodCIDRs
        // if v1.PodCIDRs was empty but v1.PodCIDR is not, then set core.PodCIDRs[0] with v1.PodCIDR
        if len(in.PodCIDR) > 0 && len(in.PodCIDRs) == 0 {
                out.PodCIDRs = []string{in.PodCIDR}
        }
        return nil
}

func Convert_v1_PodSpec_To_core_PodSpec(in *v1.PodSpec, out *core.PodSpec, s conversion.Scope) error {
        if err := autoConvert_v1_PodSpec_To_core_PodSpec(in, out, s); err != nil {
                return err
        }

        // We support DeprecatedServiceAccount as an alias for ServiceAccountName.
        // If both are specified, ServiceAccountName (the new field) wins.
        if in.ServiceAccountName == "" {
                out.ServiceAccountName = in.DeprecatedServiceAccount
        }

        // the host namespace fields have to be handled specially for backward compatibility
        // with v1.0.0
        if out.SecurityContext == nil {
                out.SecurityContext = new(core.PodSecurityContext)
        }
        out.SecurityContext.HostNetwork = in.HostNetwork
        out.SecurityContext.HostPID = in.HostPID
        out.SecurityContext.HostIPC = in.HostIPC
        out.SecurityContext.ShareProcessNamespace = in.ShareProcessNamespace
        out.SecurityContext.HostUsers = in.HostUsers

        return nil
}

func Convert_v1_Pod_To_core_Pod(in *v1.Pod, out *core.Pod, s conversion.Scope) error {
        if err := autoConvert_v1_Pod_To_core_Pod(in, out, s); err != nil {
                return err
        }

        // drop init container annotations so they don't show up as differences when receiving requests from old clients
        out.Annotations = dropInitContainerAnnotations(out.Annotations)

        // Forcing the value of TerminationGracePeriodSeconds to 1 if it is negative.
        // Just for Pod, not for PodSpec, because we don't want to change the behavior of the PodTemplate.
        if in.Spec.TerminationGracePeriodSeconds != nil && *in.Spec.TerminationGracePeriodSeconds < 0 {
                out.Spec.TerminationGracePeriodSeconds = ptr.To[int64](1)
        }
        return nil
}

func Convert_core_Pod_To_v1_Pod(in *core.Pod, out *v1.Pod, s conversion.Scope) error {
        if err := autoConvert_core_Pod_To_v1_Pod(in, out, s); err != nil {
                return err
        }

        // drop init container annotations so they don't take effect on legacy kubelets.
        // remove this once the oldest supported kubelet no longer honors the annotations over the field.
        out.Annotations = dropInitContainerAnnotations(out.Annotations)

        // Forcing the value of TerminationGracePeriodSeconds to 1 if it is negative.
        // Just for Pod, not for PodSpec, because we don't want to change the behavior of the PodTemplate.
        if in.Spec.TerminationGracePeriodSeconds != nil && *in.Spec.TerminationGracePeriodSeconds < 0 {
                out.Spec.TerminationGracePeriodSeconds = ptr.To[int64](1)
        }
        return nil
}

func Convert_v1_Secret_To_core_Secret(in *v1.Secret, out *core.Secret, s conversion.Scope) error {
        if err := autoConvert_v1_Secret_To_core_Secret(in, out, s); err != nil {
                return err
        }

        // StringData overwrites Data
        if len(in.StringData) > 0 {
                if out.Data == nil {
                        out.Data = map[string][]byte{}
                }
                for k, v := range in.StringData {
                        out.Data[k] = []byte(v)
                }
        }

        return nil
}

// +k8s:conversion-fn=copy-only
func Convert_v1_ResourceList_To_core_ResourceList(in *v1.ResourceList, out *core.ResourceList, s conversion.Scope) error {
        if *in == nil {
                return nil
        }
        if *out == nil {
                *out = make(core.ResourceList, len(*in))
        }
        for key, val := range *in {
                // Moved to defaults
                // TODO(#18538): We round up resource values to milli scale to maintain API compatibility.
                // In the future, we should instead reject values that need rounding.
                // const milliScale = -3
                // val.RoundUp(milliScale)

                (*out)[core.ResourceName(key)] = val
        }
        return nil
}

func AddFieldLabelConversionsForEvent(scheme *runtime.Scheme) error {
        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Event"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "involvedObject.kind",
                                "involvedObject.namespace",
                                "involvedObject.name",
                                "involvedObject.uid",
                                "involvedObject.apiVersion",
                                "involvedObject.resourceVersion",
                                "involvedObject.fieldPath",
                                "reason",
                                "reportingComponent",
                                "source",
                                "type",
                                "metadata.namespace",
                                "metadata.name":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                })
}

func AddFieldLabelConversionsForNamespace(scheme *runtime.Scheme) error {
        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Namespace"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "status.phase",
                                "metadata.name":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                })
}

func AddFieldLabelConversionsForSecret(scheme *runtime.Scheme) error {
        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Secret"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "type",
                                "metadata.namespace",
                                "metadata.name":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                })
}

func AddFieldLabelConversionsForService(scheme *runtime.Scheme) error {
        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Service"),
                func(label, value string) (string, string, error) {
                        switch label {
                        case "metadata.namespace",
                                "metadata.name",
                                "spec.clusterIP",
                                "spec.type":
                                return label, value, nil
                        default:
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                })
}

var initContainerAnnotations = map[string]bool{
        "pod.beta.kubernetes.io/init-containers":          true,
        "pod.alpha.kubernetes.io/init-containers":         true,
        "pod.beta.kubernetes.io/init-container-statuses":  true,
        "pod.alpha.kubernetes.io/init-container-statuses": true,
}

// dropInitContainerAnnotations returns a copy of the annotations with init container annotations removed,
// or the original annotations if no init container annotations were present.
//
// this can be removed once no clients prior to 1.8 are supported, and no kubelets prior to 1.8 can be run
// (we don't support kubelets older than 2 versions skewed from the apiserver, but we don't prevent them, either)
func dropInitContainerAnnotations(oldAnnotations map[string]string) map[string]string {
        if len(oldAnnotations) == 0 {
                return oldAnnotations
        }

        found := false
        for k := range initContainerAnnotations {
                if _, ok := oldAnnotations[k]; ok {
                        found = true
                        break
                }
        }
        if !found {
                return oldAnnotations
        }

        newAnnotations := make(map[string]string, len(oldAnnotations))
        for k, v := range oldAnnotations {
                if !initContainerAnnotations[k] {
                        newAnnotations[k] = v
                }
        }
        return newAnnotations
}

// Convert_core_PersistentVolumeSpec_To_v1_PersistentVolumeSpec is defined outside the autogenerated file for use by other API packages
// This is needed because it is referenced from other APIs, but is invisible at code-generation time because of the build tags.
func Convert_core_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in *core.PersistentVolumeSpec, out *v1.PersistentVolumeSpec, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in, out, s)
}

// Convert_v1_PersistentVolumeSpec_To_core_PersistentVolumeSpec is defined outside the autogenerated file for use by other API packages
// This is needed because it is referenced from other APIs, but is invisible at code-generation time because of the build tags.
func Convert_v1_PersistentVolumeSpec_To_core_PersistentVolumeSpec(in *v1.PersistentVolumeSpec, out *core.PersistentVolumeSpec, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeSpec_To_core_PersistentVolumeSpec(in, out, s)
}

// Convert_Slice_string_To_Pointer_string is needed because decoding URL parameters requires manual assistance.
func Convert_Slice_string_To_Pointer_string(in *[]string, out **string, s conversion.Scope) error {
        if len(*in) == 0 {
                return nil
        }
        temp := (*in)[0]
        *out = &temp
        return nil
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1

import (
        "time"

        "k8s.io/utils/ptr"

        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/util/intstr"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        resourcehelper "k8s.io/component-helpers/resource"
        "k8s.io/kubernetes/pkg/api/v1/service"
        corev1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"
        "k8s.io/kubernetes/pkg/features"
        "k8s.io/kubernetes/pkg/util/parsers"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_ResourceList(obj *v1.ResourceList) {
        for key, val := range *obj {
                // TODO(#18538): We round up resource values to milli scale to maintain API compatibility.
                // In the future, we should instead reject values that need rounding.
                const milliScale = -3
                val.RoundUp(milliScale)

                (*obj)[v1.ResourceName(key)] = val
        }
}

func SetDefaults_ReplicationController(obj *v1.ReplicationController) {
        var labels map[string]string
        if obj.Spec.Template != nil {
                labels = obj.Spec.Template.Labels
        }
        // TODO: support templates defined elsewhere when we support them in the API
        if labels != nil {
                if len(obj.Spec.Selector) == 0 {
                        obj.Spec.Selector = labels
                }
                if len(obj.Labels) == 0 {
                        obj.Labels = labels
                }
        }
        // obj.Spec.Replicas is defaulted declaratively
}
func SetDefaults_Volume(obj *v1.Volume) {
        if ptr.AllPtrFieldsNil(&obj.VolumeSource) {
                obj.VolumeSource = v1.VolumeSource{
                        EmptyDir: &v1.EmptyDirVolumeSource{},
                }
        }
        if utilfeature.DefaultFeatureGate.Enabled(features.ImageVolume) && obj.Image != nil && obj.Image.PullPolicy == "" {
                // PullPolicy defaults to Always if :latest tag is specified, or IfNotPresent otherwise.
                _, tag, _, _ := parsers.ParseImageName(obj.Image.Reference)
                if tag == "latest" {
                        obj.Image.PullPolicy = v1.PullAlways
                } else {
                        obj.Image.PullPolicy = v1.PullIfNotPresent
                }
        }
}
func SetDefaults_Container(obj *v1.Container) {
        if obj.ImagePullPolicy == "" {
                // Ignore error and assume it has been validated elsewhere
                _, tag, _, _ := parsers.ParseImageName(obj.Image)

                // Check image tag
                if tag == "latest" {
                        obj.ImagePullPolicy = v1.PullAlways
                } else {
                        obj.ImagePullPolicy = v1.PullIfNotPresent
                }
        }
        if obj.TerminationMessagePath == "" {
                obj.TerminationMessagePath = v1.TerminationMessagePathDefault
        }
        if obj.TerminationMessagePolicy == "" {
                obj.TerminationMessagePolicy = v1.TerminationMessageReadFile
        }
}

func SetDefaults_EphemeralContainer(obj *v1.EphemeralContainer) {
        SetDefaults_Container((*v1.Container)(&obj.EphemeralContainerCommon))
}

func SetDefaults_Service(obj *v1.Service) {
        if obj.Spec.SessionAffinity == "" {
                obj.Spec.SessionAffinity = v1.ServiceAffinityNone
        }
        if obj.Spec.SessionAffinity == v1.ServiceAffinityNone {
                obj.Spec.SessionAffinityConfig = nil
        }
        if obj.Spec.SessionAffinity == v1.ServiceAffinityClientIP {
                if obj.Spec.SessionAffinityConfig == nil || obj.Spec.SessionAffinityConfig.ClientIP == nil || obj.Spec.SessionAffinityConfig.ClientIP.TimeoutSeconds == nil {
                        timeoutSeconds := v1.DefaultClientIPServiceAffinitySeconds
                        obj.Spec.SessionAffinityConfig = &v1.SessionAffinityConfig{
                                ClientIP: &v1.ClientIPConfig{
                                        TimeoutSeconds: &timeoutSeconds,
                                },
                        }
                }
        }
        if obj.Spec.Type == "" {
                obj.Spec.Type = v1.ServiceTypeClusterIP
        }
        for i := range obj.Spec.Ports {
                sp := &obj.Spec.Ports[i]
                if sp.Protocol == "" {
                        sp.Protocol = v1.ProtocolTCP
                }
                if sp.TargetPort == intstr.FromInt32(0) || sp.TargetPort == intstr.FromString("") {
                        sp.TargetPort = intstr.FromInt32(sp.Port)
                }
        }
        // Defaults ExternalTrafficPolicy field for externally-accessible service
        // to Global for consistency.
        if service.ExternallyAccessible(obj) && obj.Spec.ExternalTrafficPolicy == "" {
                obj.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyCluster
        }

        if obj.Spec.InternalTrafficPolicy == nil {
                if obj.Spec.Type == v1.ServiceTypeNodePort || obj.Spec.Type == v1.ServiceTypeLoadBalancer || obj.Spec.Type == v1.ServiceTypeClusterIP {
                        serviceInternalTrafficPolicyCluster := v1.ServiceInternalTrafficPolicyCluster
                        obj.Spec.InternalTrafficPolicy = &serviceInternalTrafficPolicyCluster
                }
        }

        if obj.Spec.Type == v1.ServiceTypeLoadBalancer {
                if obj.Spec.AllocateLoadBalancerNodePorts == nil {
                        obj.Spec.AllocateLoadBalancerNodePorts = ptr.To(true)
                }
        }

        if obj.Spec.Type == v1.ServiceTypeLoadBalancer {
                if utilfeature.DefaultFeatureGate.Enabled(features.LoadBalancerIPMode) {
                        ipMode := v1.LoadBalancerIPModeVIP

                        for i, ing := range obj.Status.LoadBalancer.Ingress {
                                if ing.IP != "" && ing.IPMode == nil {
                                        obj.Status.LoadBalancer.Ingress[i].IPMode = &ipMode
                                }
                        }
                }
        }

}
func SetDefaults_Pod(obj *v1.Pod) {
        // If limits are specified, but requests are not, default requests to limits
        // This is done here rather than a more specific defaulting pass on v1.ResourceRequirements
        // because we only want this defaulting semantic to take place on a v1.Pod and not a v1.PodTemplate
        for i := range obj.Spec.Containers {
                // set requests to limits if requests are not specified, but limits are
                if obj.Spec.Containers[i].Resources.Limits != nil {
                        if obj.Spec.Containers[i].Resources.Requests == nil {
                                obj.Spec.Containers[i].Resources.Requests = make(v1.ResourceList)
                        }
                        for key, value := range obj.Spec.Containers[i].Resources.Limits {
                                if _, exists := obj.Spec.Containers[i].Resources.Requests[key]; !exists {
                                        obj.Spec.Containers[i].Resources.Requests[key] = value.DeepCopy()
                                }
                        }
                }
        }
        for i := range obj.Spec.InitContainers {
                if obj.Spec.InitContainers[i].Resources.Limits != nil {
                        if obj.Spec.InitContainers[i].Resources.Requests == nil {
                                obj.Spec.InitContainers[i].Resources.Requests = make(v1.ResourceList)
                        }
                        for key, value := range obj.Spec.InitContainers[i].Resources.Limits {
                                if _, exists := obj.Spec.InitContainers[i].Resources.Requests[key]; !exists {
                                        obj.Spec.InitContainers[i].Resources.Requests[key] = value.DeepCopy()
                                }
                        }
                }
        }

        // Pod Requests default values must be applied after container-level default values
        // have been populated.
        if utilfeature.DefaultFeatureGate.Enabled(features.PodLevelResources) {
                defaultHugePagePodLimits(obj)
                defaultPodRequests(obj)
        }

        if obj.Spec.EnableServiceLinks == nil {
                enableServiceLinks := v1.DefaultEnableServiceLinks
                obj.Spec.EnableServiceLinks = &enableServiceLinks
        }

        if obj.Spec.HostNetwork {
                defaultHostNetworkPorts(&obj.Spec.Containers)
                defaultHostNetworkPorts(&obj.Spec.InitContainers)
        }
}
func SetDefaults_PodSpec(obj *v1.PodSpec) {
        // New fields added here will break upgrade tests:
        // https://github.com/kubernetes/kubernetes/issues/69445
        // In most cases the new defaulted field can added to SetDefaults_Pod instead of here, so
        // that it only materializes in the Pod object and not all objects with a PodSpec field.
        if obj.DNSPolicy == "" {
                obj.DNSPolicy = v1.DNSClusterFirst
        }
        if obj.RestartPolicy == "" {
                obj.RestartPolicy = v1.RestartPolicyAlways
        }
        if obj.SecurityContext == nil {
                obj.SecurityContext = &v1.PodSecurityContext{}
        }
        if obj.TerminationGracePeriodSeconds == nil {
                period := int64(v1.DefaultTerminationGracePeriodSeconds)
                obj.TerminationGracePeriodSeconds = &period
        }
        if obj.SchedulerName == "" {
                obj.SchedulerName = v1.DefaultSchedulerName
        }
}
func SetDefaults_Probe(obj *v1.Probe) {
        if obj.TimeoutSeconds == 0 {
                obj.TimeoutSeconds = 1
        }
        if obj.PeriodSeconds == 0 {
                obj.PeriodSeconds = 10
        }
        if obj.SuccessThreshold == 0 {
                obj.SuccessThreshold = 1
        }
        if obj.FailureThreshold == 0 {
                obj.FailureThreshold = 3
        }
}
func SetDefaults_SecretVolumeSource(obj *v1.SecretVolumeSource) {
        if obj.DefaultMode == nil {
                perm := int32(v1.SecretVolumeSourceDefaultMode)
                obj.DefaultMode = &perm
        }
}
func SetDefaults_ConfigMapVolumeSource(obj *v1.ConfigMapVolumeSource) {
        if obj.DefaultMode == nil {
                perm := int32(v1.ConfigMapVolumeSourceDefaultMode)
                obj.DefaultMode = &perm
        }
}
func SetDefaults_DownwardAPIVolumeSource(obj *v1.DownwardAPIVolumeSource) {
        if obj.DefaultMode == nil {
                perm := int32(v1.DownwardAPIVolumeSourceDefaultMode)
                obj.DefaultMode = &perm
        }
}
func SetDefaults_Secret(obj *v1.Secret) {
        if obj.Type == "" {
                obj.Type = v1.SecretTypeOpaque
        }
}
func SetDefaults_ProjectedVolumeSource(obj *v1.ProjectedVolumeSource) {
        if obj.DefaultMode == nil {
                perm := int32(v1.ProjectedVolumeSourceDefaultMode)
                obj.DefaultMode = &perm
        }
}
func SetDefaults_ServiceAccountTokenProjection(obj *v1.ServiceAccountTokenProjection) {
        hour := int64(time.Hour.Seconds())
        if obj.ExpirationSeconds == nil {
                obj.ExpirationSeconds = &hour
        }
}
func SetDefaults_PersistentVolume(obj *v1.PersistentVolume) {
        if obj.Status.Phase == "" {
                obj.Status.Phase = v1.VolumePending
        }
        if obj.Spec.PersistentVolumeReclaimPolicy == "" {
                obj.Spec.PersistentVolumeReclaimPolicy = v1.PersistentVolumeReclaimRetain
        }
        if obj.Spec.VolumeMode == nil {
                obj.Spec.VolumeMode = new(v1.PersistentVolumeMode)
                *obj.Spec.VolumeMode = v1.PersistentVolumeFilesystem
        }
}
func SetDefaults_PersistentVolumeClaim(obj *v1.PersistentVolumeClaim) {
        if obj.Status.Phase == "" {
                obj.Status.Phase = v1.ClaimPending
        }
}
func SetDefaults_PersistentVolumeClaimSpec(obj *v1.PersistentVolumeClaimSpec) {
        if obj.VolumeMode == nil {
                obj.VolumeMode = new(v1.PersistentVolumeMode)
                *obj.VolumeMode = v1.PersistentVolumeFilesystem
        }
}
func SetDefaults_Endpoints(obj *v1.Endpoints) {
        for i := range obj.Subsets {
                ss := &obj.Subsets[i]
                for i := range ss.Ports {
                        ep := &ss.Ports[i]
                        if ep.Protocol == "" {
                                ep.Protocol = v1.ProtocolTCP
                        }
                }
        }
}
func SetDefaults_HTTPGetAction(obj *v1.HTTPGetAction) {
        if obj.Path == "" {
                obj.Path = "/"
        }
        if obj.Scheme == "" {
                obj.Scheme = v1.URISchemeHTTP
        }
}

// SetDefaults_Namespace adds a default label for all namespaces
func SetDefaults_Namespace(obj *v1.Namespace) {
        // we can't SetDefaults for nameless namespaces (generateName).
        // This code needs to be kept in sync with the implementation that exists
        // in Namespace Canonicalize strategy (pkg/registry/core/namespace)

        // note that this can result in many calls to feature enablement in some cases, but
        // we assume that there's no real cost there.
        if len(obj.Name) > 0 {
                if obj.Labels == nil {
                        obj.Labels = map[string]string{}
                }
                obj.Labels[v1.LabelMetadataName] = obj.Name
        }
}

func SetDefaults_NamespaceStatus(obj *v1.NamespaceStatus) {
        if obj.Phase == "" {
                obj.Phase = v1.NamespaceActive
        }
}
func SetDefaults_NodeStatus(obj *v1.NodeStatus) {
        if obj.Allocatable == nil && obj.Capacity != nil {
                obj.Allocatable = make(v1.ResourceList, len(obj.Capacity))
                for key, value := range obj.Capacity {
                        obj.Allocatable[key] = value.DeepCopy()
                }
                obj.Allocatable = obj.Capacity
        }
}
func SetDefaults_ObjectFieldSelector(obj *v1.ObjectFieldSelector) {
        if obj.APIVersion == "" {
                obj.APIVersion = "v1"
        }
}
func SetDefaults_LimitRangeItem(obj *v1.LimitRangeItem) {
        // for container limits, we apply default values
        if obj.Type == v1.LimitTypeContainer {

                if obj.Default == nil {
                        obj.Default = make(v1.ResourceList)
                }
                if obj.DefaultRequest == nil {
                        obj.DefaultRequest = make(v1.ResourceList)
                }

                // If a default limit is unspecified, but the max is specified, default the limit to the max
                for key, value := range obj.Max {
                        if _, exists := obj.Default[key]; !exists {
                                obj.Default[key] = value.DeepCopy()
                        }
                }
                // If a default limit is specified, but the default request is not, default request to limit
                for key, value := range obj.Default {
                        if _, exists := obj.DefaultRequest[key]; !exists {
                                obj.DefaultRequest[key] = value.DeepCopy()
                        }
                }
                // If a default request is not specified, but the min is provided, default request to the min
                for key, value := range obj.Min {
                        if _, exists := obj.DefaultRequest[key]; !exists {
                                obj.DefaultRequest[key] = value.DeepCopy()
                        }
                }
        }
}
func SetDefaults_ConfigMap(obj *v1.ConfigMap) {
        if obj.Data == nil {
                obj.Data = make(map[string]string)
        }
}

// With host networking default all container ports to host ports.
func defaultHostNetworkPorts(containers *[]v1.Container) {
        for i := range *containers {
                for j := range (*containers)[i].Ports {
                        if (*containers)[i].Ports[j].HostPort == 0 {
                                (*containers)[i].Ports[j].HostPort = (*containers)[i].Ports[j].ContainerPort
                        }
                }
        }
}

func SetDefaults_HostPathVolumeSource(obj *v1.HostPathVolumeSource) {
        typeVol := v1.HostPathUnset
        if obj.Type == nil {
                obj.Type = &typeVol
        }
}

func SetDefaults_PodLogOptions(obj *v1.PodLogOptions) {
        if utilfeature.DefaultFeatureGate.Enabled(features.PodLogsQuerySplitStreams) {
                if obj.Stream == nil {
                        obj.Stream = ptr.To(v1.LogStreamAll)
                }
        }
}

// defaultPodRequests applies default values for pod-level requests, only when
// pod-level limits are set, in following scenarios:
// 1. When at least one container (regular, init or sidecar) has requests set:
// The pod-level requests become equal to the effective requests of all containers
// in the pod.
// 2. When no containers have requests set: The pod-level requests become equal to
// pod-level limits.
// This defaulting behavior ensures consistent resource accounting at the pod-level
// while maintaining compatibility with the container-level specifications, as detailed
// in KEP-2837: https://github.com/kubernetes/enhancements/blob/master/keps/sig-node/2837-pod-level-resource-spec/README.md#proposed-validation--defaulting-rules
func defaultPodRequests(obj *v1.Pod) {
        // We only populate defaults when the pod-level resources are partly specified already.
        if obj.Spec.Resources == nil {
                return
        }

        if len(obj.Spec.Resources.Limits) == 0 {
                return
        }

        var podReqs v1.ResourceList
        podReqs = obj.Spec.Resources.Requests
        if podReqs == nil {
                podReqs = make(v1.ResourceList)
        }

        aggrCtrReqs := resourcehelper.AggregateContainerRequests(obj, resourcehelper.PodResourcesOptions{})

        // When containers specify requests for a resource (supported by
        // PodLevelResources feature) and pod-level requests are not set, the pod-level requests
        // default to the effective requests of all the containers for that resource.
        for key, aggrCtrLim := range aggrCtrReqs {
                // Default pod level requests for overcommittable resources from aggregated container requests.
                if _, exists := podReqs[key]; !exists && resourcehelper.IsSupportedPodLevelResource(key) && corev1helper.IsOvercommitAllowed(key) {
                        podReqs[key] = aggrCtrLim.DeepCopy()
                }
        }

        // When no containers specify requests for a resource, the pod-level requests
        // will default to match the pod-level limits, if pod-level
        // limits exist for that resource.
        // Defaulting for pod level hugepages requests is dependent on defaultHugePagePodLimits,
        // if defaultHugePagePodLimits defined the limit, the request will be set here.
        for key, podLim := range obj.Spec.Resources.Limits {
                if _, exists := podReqs[key]; !exists && resourcehelper.IsSupportedPodLevelResource(key) {
                        podReqs[key] = podLim.DeepCopy()
                }
        }

        // Only set pod-level resource requests in the PodSpec if the requirements map
        // contains entries after collecting container-level requests and pod-level limits.
        if len(podReqs) > 0 {
                obj.Spec.Resources.Requests = podReqs
        }
}

// defaultHugePagePodLimits applies default values for pod-level limits, only when
// container hugepage limits are set, but not at pod level, in following
// scenario:
// 1. When at least one container (regular, init or sidecar) has hugepage
// limits set:
// The pod-level limit becomes equal to the aggregated hugepages limit of all
// the containers in the pod.
func defaultHugePagePodLimits(pod *v1.Pod) {
        // We only populate hugepage limit defaults when the pod-level resources are partly specified.
        if pod.Spec.Resources == nil {
                return
        }

        if len(pod.Spec.Resources.Limits) == 0 && len(pod.Spec.Resources.Requests) == 0 {
                return
        }

        var podLims v1.ResourceList
        podLims = pod.Spec.Resources.Limits
        if podLims == nil {
                podLims = make(v1.ResourceList)
        }

        aggrCtrLims := resourcehelper.AggregateContainerLimits(pod, resourcehelper.PodResourcesOptions{})

        // When containers specify limits for hugepages and pod-level limits are not
        // set for that resource, the pod-level limit will default to the aggregated
        // hugepages limit of all the containers.
        for key, aggrCtrLim := range aggrCtrLims {
                if !resourcehelper.IsSupportedPodLevelResource(key) || !corev1helper.IsHugePageResourceName(key) {
                        continue
                }

                // We do not default pod-level hugepage limits if there is a hugepage request.
                if _, exists := pod.Spec.Resources.Requests[key]; exists {
                        continue
                }

                if _, exists := podLims[key]; !exists {
                        podLims[key] = aggrCtrLim.DeepCopy()
                }
        }

        // Only set pod-level resource limits in the PodSpec if the requirements map
        // contains entries after collecting container-level limits and pod-level limits for hugepages.
        if len(podLims) > 0 {
                pod.Spec.Resources.Limits = podLims
        }
}

/*
Copyright 2014 The Kubernetes Authors.

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.
*/

package helper

import (
        "fmt"
        "strings"

        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/api/resource"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/apimachinery/pkg/selection"
        "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/kubernetes/pkg/apis/core/helper"
)

// IsExtendedResourceName returns true if:
// 1. the resource name is not in the default namespace;
// 2. resource name does not have "requests." prefix,
// to avoid confusion with the convention in quota
// 3. it satisfies the rules in IsQualifiedName() after converted into quota resource name
func IsExtendedResourceName(name v1.ResourceName) bool {
        if IsNativeResource(name) || strings.HasPrefix(string(name), v1.DefaultResourceRequestsPrefix) {
                return false
        }
        // Ensure it satisfies the rules in IsQualifiedName() after converted into quota resource name
        nameForQuota := fmt.Sprintf("%s%s", v1.DefaultResourceRequestsPrefix, string(name))
        if errs := validation.IsQualifiedName(nameForQuota); len(errs) != 0 {
                return false
        }
        return true
}

// IsPrefixedNativeResource returns true if the resource name is in the
// *kubernetes.io/ namespace.
func IsPrefixedNativeResource(name v1.ResourceName) bool {
        return strings.Contains(string(name), v1.ResourceDefaultNamespacePrefix)
}

// IsNativeResource returns true if the resource name is in the
// *kubernetes.io/ namespace. Partially-qualified (unprefixed) names are
// implicitly in the kubernetes.io/ namespace.
func IsNativeResource(name v1.ResourceName) bool {
        return !strings.Contains(string(name), "/") ||
                IsPrefixedNativeResource(name)
}

// IsHugePageResourceName returns true if the resource name has the huge page
// resource prefix.
func IsHugePageResourceName(name v1.ResourceName) bool {
        return strings.HasPrefix(string(name), v1.ResourceHugePagesPrefix)
}

// HugePageResourceName returns a ResourceName with the canonical hugepage
// prefix prepended for the specified page size.  The page size is converted
// to its canonical representation.
func HugePageResourceName(pageSize resource.Quantity) v1.ResourceName {
        return v1.ResourceName(fmt.Sprintf("%s%s", v1.ResourceHugePagesPrefix, pageSize.String()))
}

// HugePageSizeFromResourceName returns the page size for the specified huge page
// resource name.  If the specified input is not a valid huge page resource name
// an error is returned.
func HugePageSizeFromResourceName(name v1.ResourceName) (resource.Quantity, error) {
        if !IsHugePageResourceName(name) {
                return resource.Quantity{}, fmt.Errorf("resource name: %s is an invalid hugepage name", name)
        }
        pageSize := strings.TrimPrefix(string(name), v1.ResourceHugePagesPrefix)
        return resource.ParseQuantity(pageSize)
}

// HugePageUnitSizeFromByteSize returns hugepage size has the format.
// `size` must be guaranteed to divisible into the largest units that can be expressed.
// <size><unit-prefix>B (1024 = "1KB", 1048576 = "1MB", etc).
func HugePageUnitSizeFromByteSize(size int64) (string, error) {
        // hugePageSizeUnitList is borrowed from opencontainers/runc/libcontainer/cgroups/utils.go
        var hugePageSizeUnitList = []string{"B", "KB", "MB", "GB", "TB", "PB"}
        idx := 0
        len := len(hugePageSizeUnitList) - 1
        for size%1024 == 0 && idx < len {
                size /= 1024
                idx++
        }
        if size > 1024 && idx < len {
                return "", fmt.Errorf("size: %d%s must be guaranteed to divisible into the largest units", size, hugePageSizeUnitList[idx])
        }
        return fmt.Sprintf("%d%s", size, hugePageSizeUnitList[idx]), nil
}

// IsHugePageMedium returns true if the volume medium is in 'HugePages[-size]' format
func IsHugePageMedium(medium v1.StorageMedium) bool {
        if medium == v1.StorageMediumHugePages {
                return true
        }
        return strings.HasPrefix(string(medium), string(v1.StorageMediumHugePagesPrefix))
}

// HugePageSizeFromMedium returns the page size for the specified huge page medium.
// If the specified input is not a valid huge page medium an error is returned.
func HugePageSizeFromMedium(medium v1.StorageMedium) (resource.Quantity, error) {
        if !IsHugePageMedium(medium) {
                return resource.Quantity{}, fmt.Errorf("medium: %s is not a hugepage medium", medium)
        }
        if medium == v1.StorageMediumHugePages {
                return resource.Quantity{}, fmt.Errorf("medium: %s doesn't have size information", medium)
        }
        pageSize := strings.TrimPrefix(string(medium), string(v1.StorageMediumHugePagesPrefix))
        return resource.ParseQuantity(pageSize)
}

// IsOvercommitAllowed returns true if the resource is in the default
// namespace and is not hugepages.
func IsOvercommitAllowed(name v1.ResourceName) bool {
        return IsNativeResource(name) &&
                !IsHugePageResourceName(name)
}

// IsAttachableVolumeResourceName returns true when the resource name is prefixed in attachable volume
func IsAttachableVolumeResourceName(name v1.ResourceName) bool {
        return strings.HasPrefix(string(name), v1.ResourceAttachableVolumesPrefix)
}

// IsServiceIPSet aims to check if the service's ClusterIP is set or not
// the objective is not to perform validation here
func IsServiceIPSet(service *v1.Service) bool {
        return service.Spec.ClusterIP != v1.ClusterIPNone && service.Spec.ClusterIP != ""
}

// GetAccessModesAsString returns a string representation of an array of access modes.
// modes, when present, are always in the same order: RWO,ROX,RWX,RWOP.
func GetAccessModesAsString(modes []v1.PersistentVolumeAccessMode) string {
        modes = removeDuplicateAccessModes(modes)
        modesStr := []string{}
        if ContainsAccessMode(modes, v1.ReadWriteOnce) {
                modesStr = append(modesStr, "RWO")
        }
        if ContainsAccessMode(modes, v1.ReadOnlyMany) {
                modesStr = append(modesStr, "ROX")
        }
        if ContainsAccessMode(modes, v1.ReadWriteMany) {
                modesStr = append(modesStr, "RWX")
        }
        if ContainsAccessMode(modes, v1.ReadWriteOncePod) {
                modesStr = append(modesStr, "RWOP")
        }
        return strings.Join(modesStr, ",")
}

// GetAccessModesFromString returns an array of AccessModes from a string created by GetAccessModesAsString
func GetAccessModesFromString(modes string) []v1.PersistentVolumeAccessMode {
        strmodes := strings.Split(modes, ",")
        accessModes := []v1.PersistentVolumeAccessMode{}
        for _, s := range strmodes {
                s = strings.Trim(s, " ")
                switch {
                case s == "RWO":
                        accessModes = append(accessModes, v1.ReadWriteOnce)
                case s == "ROX":
                        accessModes = append(accessModes, v1.ReadOnlyMany)
                case s == "RWX":
                        accessModes = append(accessModes, v1.ReadWriteMany)
                case s == "RWOP":
                        accessModes = append(accessModes, v1.ReadWriteOncePod)
                }
        }
        return accessModes
}

// removeDuplicateAccessModes returns an array of access modes without any duplicates
func removeDuplicateAccessModes(modes []v1.PersistentVolumeAccessMode) []v1.PersistentVolumeAccessMode {
        accessModes := []v1.PersistentVolumeAccessMode{}
        for _, m := range modes {
                if !ContainsAccessMode(accessModes, m) {
                        accessModes = append(accessModes, m)
                }
        }
        return accessModes
}

func ContainsAccessMode(modes []v1.PersistentVolumeAccessMode, mode v1.PersistentVolumeAccessMode) bool {
        for _, m := range modes {
                if m == mode {
                        return true
                }
        }
        return false
}

// NodeSelectorRequirementKeysExistInNodeSelectorTerms checks if a NodeSelectorTerm with key is already specified in terms
func NodeSelectorRequirementKeysExistInNodeSelectorTerms(reqs []v1.NodeSelectorRequirement, terms []v1.NodeSelectorTerm) bool {
        for _, req := range reqs {
                for _, term := range terms {
                        for _, r := range term.MatchExpressions {
                                if r.Key == req.Key {
                                        return true
                                }
                        }
                }
        }
        return false
}

// TopologySelectorRequirementsAsSelector converts the []TopologySelectorLabelRequirement api type into a struct
// that implements labels.Selector.
func TopologySelectorRequirementsAsSelector(tsm []v1.TopologySelectorLabelRequirement) (labels.Selector, error) {
        if len(tsm) == 0 {
                return labels.Nothing(), nil
        }

        selector := labels.NewSelector()
        for _, expr := range tsm {
                r, err := labels.NewRequirement(expr.Key, selection.In, expr.Values)
                if err != nil {
                        return nil, err
                }
                selector = selector.Add(*r)
        }

        return selector, nil
}

// MatchTopologySelectorTerms checks whether given labels match topology selector terms in ORed;
// nil or empty term matches no objects; while empty term list matches all objects.
func MatchTopologySelectorTerms(topologySelectorTerms []v1.TopologySelectorTerm, lbls labels.Set) bool {
        if len(topologySelectorTerms) == 0 {
                // empty term list matches all objects
                return true
        }

        for _, req := range topologySelectorTerms {
                // nil or empty term selects no objects
                if len(req.MatchLabelExpressions) == 0 {
                        continue
                }

                labelSelector, err := TopologySelectorRequirementsAsSelector(req.MatchLabelExpressions)
                if err != nil || !labelSelector.Matches(lbls) {
                        continue
                }

                return true
        }

        return false
}

// AddOrUpdateTolerationInPodSpec tries to add a toleration to the toleration list in PodSpec.
// Returns true if something was updated, false otherwise.
func AddOrUpdateTolerationInPodSpec(spec *v1.PodSpec, toleration *v1.Toleration) bool {
        podTolerations := spec.Tolerations

        var newTolerations []v1.Toleration
        updated := false
        for i := range podTolerations {
                if toleration.MatchToleration(&podTolerations[i]) {
                        if helper.Semantic.DeepEqual(toleration, podTolerations[i]) {
                                return false
                        }
                        newTolerations = append(newTolerations, *toleration)
                        updated = true
                        continue
                }

                newTolerations = append(newTolerations, podTolerations[i])
        }

        if !updated {
                newTolerations = append(newTolerations, *toleration)
        }

        spec.Tolerations = newTolerations
        return true
}

// GetMatchingTolerations returns true and list of Tolerations matching all Taints if all are tolerated, or false otherwise.
func GetMatchingTolerations(taints []v1.Taint, tolerations []v1.Toleration) (bool, []v1.Toleration) {
        if len(taints) == 0 {
                return true, []v1.Toleration{}
        }
        if len(tolerations) == 0 && len(taints) > 0 {
                return false, []v1.Toleration{}
        }
        result := []v1.Toleration{}
        for i := range taints {
                tolerated := false
                for j := range tolerations {
                        if tolerations[j].ToleratesTaint(&taints[i]) {
                                result = append(result, tolerations[j])
                                tolerated = true
                                break
                        }
                }
                if !tolerated {
                        return false, []v1.Toleration{}
                }
        }
        return true, result
}

// ScopedResourceSelectorRequirementsAsSelector converts the ScopedResourceSelectorRequirement api type into a struct that implements
// labels.Selector.
func ScopedResourceSelectorRequirementsAsSelector(ssr v1.ScopedResourceSelectorRequirement) (labels.Selector, error) {
        selector := labels.NewSelector()
        var op selection.Operator
        switch ssr.Operator {
        case v1.ScopeSelectorOpIn:
                op = selection.In
        case v1.ScopeSelectorOpNotIn:
                op = selection.NotIn
        case v1.ScopeSelectorOpExists:
                op = selection.Exists
        case v1.ScopeSelectorOpDoesNotExist:
                op = selection.DoesNotExist
        default:
                return nil, fmt.Errorf("%q is not a valid scope selector operator", ssr.Operator)
        }
        r, err := labels.NewRequirement(string(ssr.ScopeName), op, ssr.Values)
        if err != nil {
                return nil, err
        }
        selector = selector.Add(*r)
        return selector, nil
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package qos

import (
        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/api/resource"
        "k8s.io/apimachinery/pkg/util/sets"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/features"
)

var supportedQoSComputeResources = sets.NewString(string(core.ResourceCPU), string(core.ResourceMemory))

// QOSList is a set of (resource name, QoS class) pairs.
type QOSList map[v1.ResourceName]v1.PodQOSClass

func isSupportedQoSComputeResource(name v1.ResourceName) bool {
        return supportedQoSComputeResources.Has(string(name))
}

// GetPodQOS returns the QoS class of a pod persisted in the PodStatus.QOSClass field.
// If PodStatus.QOSClass is empty, it returns value of ComputePodQOS() which evaluates pod's QoS class.
func GetPodQOS(pod *v1.Pod) v1.PodQOSClass {
        if pod.Status.QOSClass != "" {
                return pod.Status.QOSClass
        }
        return ComputePodQOS(pod)
}

// zeroQuantity represents a resource.Quantity with value "0", used as a baseline
// for resource comparisons.
var zeroQuantity = resource.MustParse("0")

// processResourceList adds non-zero quantities for supported QoS compute resources
// quantities from newList to list.
func processResourceList(list, newList v1.ResourceList) {
        for name, quantity := range newList {
                if !isSupportedQoSComputeResource(name) {
                        continue
                }
                if quantity.Cmp(zeroQuantity) == 1 {
                        delta := quantity.DeepCopy()
                        if _, exists := list[name]; !exists {
                                list[name] = delta
                        } else {
                                delta.Add(list[name])
                                list[name] = delta
                        }
                }
        }
}

// getQOSResources returns a set of resource names from the provided resource list that:
// 1. Are supported QoS compute resources
// 2. Have quantities greater than zero
func getQOSResources(list v1.ResourceList) sets.Set[string] {
        qosResources := sets.New[string]()
        for name, quantity := range list {
                if !isSupportedQoSComputeResource(name) {
                        continue
                }
                if quantity.Cmp(zeroQuantity) == 1 {
                        qosResources.Insert(string(name))
                }
        }
        return qosResources
}

// ComputePodQOS evaluates the list of containers to determine a pod's QoS class. This function is more
// expensive than GetPodQOS which should be used for pods having a non-empty .Status.QOSClass.
// A pod is besteffort if none of its containers have specified any requests or limits.
// A pod is guaranteed only when requests and limits are specified for all the containers and they are equal.
// A pod is burstable if limits and requests do not match across all containers.
// TODO(ndixita): Refactor ComputePodQOS into smaller functions to make it more
// readable and maintainable.
func ComputePodQOS(pod *v1.Pod) v1.PodQOSClass {
        requests := v1.ResourceList{}
        limits := v1.ResourceList{}
        isGuaranteed := true
        // When pod-level resources are specified, we use them to determine QoS class.
        if utilfeature.DefaultFeatureGate.Enabled(features.PodLevelResources) &&
                pod.Spec.Resources != nil {
                if len(pod.Spec.Resources.Requests) > 0 {
                        // process requests
                        processResourceList(requests, pod.Spec.Resources.Requests)
                }

                if len(pod.Spec.Resources.Limits) > 0 {
                        // process limits
                        processResourceList(limits, pod.Spec.Resources.Limits)
                        qosLimitResources := getQOSResources(pod.Spec.Resources.Limits)
                        if !qosLimitResources.HasAll(string(v1.ResourceMemory), string(v1.ResourceCPU)) {
                                isGuaranteed = false
                        }
                }
        } else {
                // note, ephemeral containers are not considered for QoS as they cannot define resources
                allContainers := []v1.Container{}
                allContainers = append(allContainers, pod.Spec.Containers...)
                allContainers = append(allContainers, pod.Spec.InitContainers...)
                for _, container := range allContainers {
                        // process requests
                        for name, quantity := range container.Resources.Requests {
                                if !isSupportedQoSComputeResource(name) {
                                        continue
                                }
                                if quantity.Cmp(zeroQuantity) == 1 {
                                        delta := quantity.DeepCopy()
                                        if _, exists := requests[name]; !exists {
                                                requests[name] = delta
                                        } else {
                                                delta.Add(requests[name])
                                                requests[name] = delta
                                        }
                                }
                        }
                        // process limits
                        qosLimitsFound := sets.NewString()
                        for name, quantity := range container.Resources.Limits {
                                if !isSupportedQoSComputeResource(name) {
                                        continue
                                }
                                if quantity.Cmp(zeroQuantity) == 1 {
                                        qosLimitsFound.Insert(string(name))
                                        delta := quantity.DeepCopy()
                                        if _, exists := limits[name]; !exists {
                                                limits[name] = delta
                                        } else {
                                                delta.Add(limits[name])
                                                limits[name] = delta
                                        }
                                }
                        }

                        if !qosLimitsFound.HasAll(string(v1.ResourceMemory), string(v1.ResourceCPU)) {
                                isGuaranteed = false
                        }
                }
        }

        if len(requests) == 0 && len(limits) == 0 {
                return v1.PodQOSBestEffort
        }
        // Check is requests match limits for all resources.
        if isGuaranteed {
                for name, req := range requests {
                        if lim, exists := limits[name]; !exists || lim.Cmp(req) != 0 {
                                isGuaranteed = false
                                break
                        }
                }
        }
        if isGuaranteed &&
                len(requests) == len(limits) {
                return v1.PodQOSGuaranteed
        }
        return v1.PodQOSBurstable
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1

import (
        "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

var (
        localSchemeBuilder = &v1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs)
}

// TODO: remove these global variables
// GroupName is the group name use in this package
const GroupName = ""

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

/*
Copyright 2014 The Kubernetes Authors.

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.
*/

package validation

import (
        "fmt"
        "strings"

        v1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/api/resource"
        "k8s.io/apimachinery/pkg/util/sets"
        "k8s.io/apimachinery/pkg/util/validation/field"

        "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/core/helper"
        v1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"
        apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
)

const isNegativeErrorMsg string = `must be greater than or equal to 0`
const isNotIntegerErrorMsg string = `must be an integer`

// ValidateResourceRequirements will check if any of the resource
// Limits/Requests are of a valid value. Any incorrect value will be added to
// the ErrorList.
func ValidateResourceRequirements(requirements *v1.ResourceRequirements, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        limPath := fldPath.Child("limits")
        reqPath := fldPath.Child("requests")
        for resourceName, quantity := range requirements.Limits {
                fldPath := limPath.Key(string(resourceName))
                // Validate resource name.
                allErrs = append(allErrs, ValidateContainerResourceName(core.ResourceName(resourceName), fldPath)...)

                // Validate resource quantity.
                allErrs = append(allErrs, ValidateResourceQuantityValue(core.ResourceName(resourceName), quantity, fldPath)...)

        }
        for resourceName, quantity := range requirements.Requests {
                fldPath := reqPath.Key(string(resourceName))
                // Validate resource name.
                allErrs = append(allErrs, ValidateContainerResourceName(core.ResourceName(resourceName), fldPath)...)
                // Validate resource quantity.
                allErrs = append(allErrs, ValidateResourceQuantityValue(core.ResourceName(resourceName), quantity, fldPath)...)

                // Check that request <= limit.
                limitQuantity, exists := requirements.Limits[resourceName]
                if exists {
                        // For GPUs, not only requests can't exceed limits, they also can't be lower, i.e. must be equal.
                        if quantity.Cmp(limitQuantity) != 0 && !v1helper.IsOvercommitAllowed(resourceName) {
                                allErrs = append(allErrs, field.Invalid(reqPath, quantity.String(), fmt.Sprintf("must be equal to %s limit of %s", resourceName, limitQuantity.String())))
                        } else if quantity.Cmp(limitQuantity) > 0 {
                                allErrs = append(allErrs, field.Invalid(reqPath, quantity.String(), fmt.Sprintf("must be less than or equal to %s limit of %s", resourceName, limitQuantity.String())))
                        }
                }
        }

        return allErrs
}

// ValidateContainerResourceName checks the name of resource specified for a container
func ValidateContainerResourceName(value core.ResourceName, fldPath *field.Path) field.ErrorList {
        allErrs := validateResourceName(value, fldPath)
        if len(strings.Split(string(value), "/")) == 1 {
                if !helper.IsStandardContainerResourceName(value) {
                        return append(allErrs, field.Invalid(fldPath, value, "must be a standard resource for containers"))
                }
        } else if !v1helper.IsNativeResource(v1.ResourceName(value)) {
                if !v1helper.IsExtendedResourceName(v1.ResourceName(value)) {
                        return append(allErrs, field.Invalid(fldPath, value, "doesn't follow extended resource name standard"))
                }
        }
        return allErrs
}

// ValidateResourceQuantityValue enforces that specified quantity is valid for specified resource
func ValidateResourceQuantityValue(resource core.ResourceName, value resource.Quantity, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateNonnegativeQuantity(value, fldPath)...)
        if helper.IsIntegerResourceName(resource) {
                if value.MilliValue()%int64(1000) != int64(0) {
                        allErrs = append(allErrs, field.Invalid(fldPath, value, isNotIntegerErrorMsg))
                }
        }
        return allErrs
}

// ValidateNonnegativeQuantity checks that a Quantity is not negative.
func ValidateNonnegativeQuantity(value resource.Quantity, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if value.Cmp(resource.Quantity{}) < 0 {
                allErrs = append(allErrs, field.Invalid(fldPath, value.String(), isNegativeErrorMsg))
        }
        return allErrs
}

// Validate compute resource typename.
// Refer to docs/design/resources.md for more details.
func validateResourceName(value core.ResourceName, fldPath *field.Path) field.ErrorList {
        allErrs := apivalidation.ValidateQualifiedName(string(value), fldPath)
        if len(allErrs) != 0 {
                return allErrs
        }

        if len(strings.Split(string(value), "/")) == 1 {
                if !helper.IsStandardResourceName(value) {
                        return append(allErrs, field.Invalid(fldPath, value, "must be a standard resource type or fully qualified"))
                }
        }

        return allErrs
}

var validLogStreams = sets.New[string](
        v1.LogStreamStdout,
        v1.LogStreamStderr,
        v1.LogStreamAll,
)

// ValidatePodLogOptions checks if options that are set are at the correct
// value. Any incorrect value will be returned to the ErrorList.
func ValidatePodLogOptions(opts *v1.PodLogOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if opts.TailLines != nil && *opts.TailLines < 0 {
                allErrs = append(allErrs, field.Invalid(field.NewPath("tailLines"), *opts.TailLines, isNegativeErrorMsg))
        }
        if opts.LimitBytes != nil && *opts.LimitBytes < 1 {
                allErrs = append(allErrs, field.Invalid(field.NewPath("limitBytes"), *opts.LimitBytes, "must be greater than 0"))
        }
        switch {
        case opts.SinceSeconds != nil && opts.SinceTime != nil:
                allErrs = append(allErrs, field.Forbidden(field.NewPath(""), "at most one of `sinceTime` or `sinceSeconds` may be specified"))
        case opts.SinceSeconds != nil:
                if *opts.SinceSeconds < 1 {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("sinceSeconds"), *opts.SinceSeconds, "must be greater than 0"))
                }
        }
        // opts.Stream can be nil because defaulting might not apply if no URL params are provided.
        if opts.Stream != nil {
                if !validLogStreams.Has(*opts.Stream) {
                        allErrs = append(allErrs, field.NotSupported(field.NewPath("stream"), *opts.Stream, validLogStreams.UnsortedList()))
                }
                if *opts.Stream != v1.LogStreamAll && opts.TailLines != nil {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath(""), "`tailLines` and specific `stream` are mutually exclusive for now"))
                }
        }
        return allErrs
}

// AccumulateUniqueHostPorts checks all the containers for duplicates ports. Any
// duplicate port will be returned in the ErrorList.
func AccumulateUniqueHostPorts(containers []v1.Container, accumulator *sets.String, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        for ci, ctr := range containers {
                idxPath := fldPath.Index(ci)
                portsPath := idxPath.Child("ports")
                for pi := range ctr.Ports {
                        idxPath := portsPath.Index(pi)
                        port := ctr.Ports[pi].HostPort
                        if port == 0 {
                                continue
                        }
                        str := fmt.Sprintf("%d/%s", port, ctr.Ports[pi].Protocol)
                        if accumulator.Has(str) {
                                allErrs = append(allErrs, field.Duplicate(idxPath.Child("hostPort"), str))
                        } else {
                                accumulator.Insert(str)
                        }
                }
        }
        return allErrs
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        url "net/url"
        unsafe "unsafe"

        corev1 "k8s.io/api/core/v1"
        resource "k8s.io/apimachinery/pkg/api/resource"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        types "k8s.io/apimachinery/pkg/types"
        apps "k8s.io/kubernetes/pkg/apis/apps"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*corev1.AWSElasticBlockStoreVolumeSource)(nil), (*core.AWSElasticBlockStoreVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AWSElasticBlockStoreVolumeSource_To_core_AWSElasticBlockStoreVolumeSource(a.(*corev1.AWSElasticBlockStoreVolumeSource), b.(*core.AWSElasticBlockStoreVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.AWSElasticBlockStoreVolumeSource)(nil), (*corev1.AWSElasticBlockStoreVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(a.(*core.AWSElasticBlockStoreVolumeSource), b.(*corev1.AWSElasticBlockStoreVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Affinity)(nil), (*core.Affinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Affinity_To_core_Affinity(a.(*corev1.Affinity), b.(*core.Affinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Affinity)(nil), (*corev1.Affinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Affinity_To_v1_Affinity(a.(*core.Affinity), b.(*corev1.Affinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.AppArmorProfile)(nil), (*core.AppArmorProfile)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AppArmorProfile_To_core_AppArmorProfile(a.(*corev1.AppArmorProfile), b.(*core.AppArmorProfile), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.AppArmorProfile)(nil), (*corev1.AppArmorProfile)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_AppArmorProfile_To_v1_AppArmorProfile(a.(*core.AppArmorProfile), b.(*corev1.AppArmorProfile), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.AttachedVolume)(nil), (*core.AttachedVolume)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AttachedVolume_To_core_AttachedVolume(a.(*corev1.AttachedVolume), b.(*core.AttachedVolume), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.AttachedVolume)(nil), (*corev1.AttachedVolume)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_AttachedVolume_To_v1_AttachedVolume(a.(*core.AttachedVolume), b.(*corev1.AttachedVolume), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.AvoidPods)(nil), (*core.AvoidPods)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AvoidPods_To_core_AvoidPods(a.(*corev1.AvoidPods), b.(*core.AvoidPods), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.AvoidPods)(nil), (*corev1.AvoidPods)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_AvoidPods_To_v1_AvoidPods(a.(*core.AvoidPods), b.(*corev1.AvoidPods), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.AzureDiskVolumeSource)(nil), (*core.AzureDiskVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AzureDiskVolumeSource_To_core_AzureDiskVolumeSource(a.(*corev1.AzureDiskVolumeSource), b.(*core.AzureDiskVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.AzureDiskVolumeSource)(nil), (*corev1.AzureDiskVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_AzureDiskVolumeSource_To_v1_AzureDiskVolumeSource(a.(*core.AzureDiskVolumeSource), b.(*corev1.AzureDiskVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.AzureFilePersistentVolumeSource)(nil), (*core.AzureFilePersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AzureFilePersistentVolumeSource_To_core_AzureFilePersistentVolumeSource(a.(*corev1.AzureFilePersistentVolumeSource), b.(*core.AzureFilePersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.AzureFilePersistentVolumeSource)(nil), (*corev1.AzureFilePersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_AzureFilePersistentVolumeSource_To_v1_AzureFilePersistentVolumeSource(a.(*core.AzureFilePersistentVolumeSource), b.(*corev1.AzureFilePersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.AzureFileVolumeSource)(nil), (*core.AzureFileVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_AzureFileVolumeSource_To_core_AzureFileVolumeSource(a.(*corev1.AzureFileVolumeSource), b.(*core.AzureFileVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.AzureFileVolumeSource)(nil), (*corev1.AzureFileVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(a.(*core.AzureFileVolumeSource), b.(*corev1.AzureFileVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Binding)(nil), (*core.Binding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Binding_To_core_Binding(a.(*corev1.Binding), b.(*core.Binding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Binding)(nil), (*corev1.Binding)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Binding_To_v1_Binding(a.(*core.Binding), b.(*corev1.Binding), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.CSIPersistentVolumeSource)(nil), (*core.CSIPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CSIPersistentVolumeSource_To_core_CSIPersistentVolumeSource(a.(*corev1.CSIPersistentVolumeSource), b.(*core.CSIPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.CSIPersistentVolumeSource)(nil), (*corev1.CSIPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_CSIPersistentVolumeSource_To_v1_CSIPersistentVolumeSource(a.(*core.CSIPersistentVolumeSource), b.(*corev1.CSIPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.CSIVolumeSource)(nil), (*core.CSIVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CSIVolumeSource_To_core_CSIVolumeSource(a.(*corev1.CSIVolumeSource), b.(*core.CSIVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.CSIVolumeSource)(nil), (*corev1.CSIVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_CSIVolumeSource_To_v1_CSIVolumeSource(a.(*core.CSIVolumeSource), b.(*corev1.CSIVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Capabilities)(nil), (*core.Capabilities)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Capabilities_To_core_Capabilities(a.(*corev1.Capabilities), b.(*core.Capabilities), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Capabilities)(nil), (*corev1.Capabilities)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Capabilities_To_v1_Capabilities(a.(*core.Capabilities), b.(*corev1.Capabilities), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.CephFSPersistentVolumeSource)(nil), (*core.CephFSPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CephFSPersistentVolumeSource_To_core_CephFSPersistentVolumeSource(a.(*corev1.CephFSPersistentVolumeSource), b.(*core.CephFSPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.CephFSPersistentVolumeSource)(nil), (*corev1.CephFSPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_CephFSPersistentVolumeSource_To_v1_CephFSPersistentVolumeSource(a.(*core.CephFSPersistentVolumeSource), b.(*corev1.CephFSPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.CephFSVolumeSource)(nil), (*core.CephFSVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CephFSVolumeSource_To_core_CephFSVolumeSource(a.(*corev1.CephFSVolumeSource), b.(*core.CephFSVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.CephFSVolumeSource)(nil), (*corev1.CephFSVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_CephFSVolumeSource_To_v1_CephFSVolumeSource(a.(*core.CephFSVolumeSource), b.(*corev1.CephFSVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.CinderPersistentVolumeSource)(nil), (*core.CinderPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CinderPersistentVolumeSource_To_core_CinderPersistentVolumeSource(a.(*corev1.CinderPersistentVolumeSource), b.(*core.CinderPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.CinderPersistentVolumeSource)(nil), (*corev1.CinderPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_CinderPersistentVolumeSource_To_v1_CinderPersistentVolumeSource(a.(*core.CinderPersistentVolumeSource), b.(*corev1.CinderPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.CinderVolumeSource)(nil), (*core.CinderVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_CinderVolumeSource_To_core_CinderVolumeSource(a.(*corev1.CinderVolumeSource), b.(*core.CinderVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.CinderVolumeSource)(nil), (*corev1.CinderVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_CinderVolumeSource_To_v1_CinderVolumeSource(a.(*core.CinderVolumeSource), b.(*corev1.CinderVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ClientIPConfig)(nil), (*core.ClientIPConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ClientIPConfig_To_core_ClientIPConfig(a.(*corev1.ClientIPConfig), b.(*core.ClientIPConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ClientIPConfig)(nil), (*corev1.ClientIPConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ClientIPConfig_To_v1_ClientIPConfig(a.(*core.ClientIPConfig), b.(*corev1.ClientIPConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ClusterTrustBundleProjection)(nil), (*core.ClusterTrustBundleProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ClusterTrustBundleProjection_To_core_ClusterTrustBundleProjection(a.(*corev1.ClusterTrustBundleProjection), b.(*core.ClusterTrustBundleProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ClusterTrustBundleProjection)(nil), (*corev1.ClusterTrustBundleProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ClusterTrustBundleProjection_To_v1_ClusterTrustBundleProjection(a.(*core.ClusterTrustBundleProjection), b.(*corev1.ClusterTrustBundleProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ComponentCondition)(nil), (*core.ComponentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ComponentCondition_To_core_ComponentCondition(a.(*corev1.ComponentCondition), b.(*core.ComponentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ComponentCondition)(nil), (*corev1.ComponentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ComponentCondition_To_v1_ComponentCondition(a.(*core.ComponentCondition), b.(*corev1.ComponentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ComponentStatus)(nil), (*core.ComponentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ComponentStatus_To_core_ComponentStatus(a.(*corev1.ComponentStatus), b.(*core.ComponentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ComponentStatus)(nil), (*corev1.ComponentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ComponentStatus_To_v1_ComponentStatus(a.(*core.ComponentStatus), b.(*corev1.ComponentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ComponentStatusList)(nil), (*core.ComponentStatusList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ComponentStatusList_To_core_ComponentStatusList(a.(*corev1.ComponentStatusList), b.(*core.ComponentStatusList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ComponentStatusList)(nil), (*corev1.ComponentStatusList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ComponentStatusList_To_v1_ComponentStatusList(a.(*core.ComponentStatusList), b.(*corev1.ComponentStatusList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ConfigMap)(nil), (*core.ConfigMap)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ConfigMap_To_core_ConfigMap(a.(*corev1.ConfigMap), b.(*core.ConfigMap), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ConfigMap)(nil), (*corev1.ConfigMap)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ConfigMap_To_v1_ConfigMap(a.(*core.ConfigMap), b.(*corev1.ConfigMap), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ConfigMapEnvSource)(nil), (*core.ConfigMapEnvSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ConfigMapEnvSource_To_core_ConfigMapEnvSource(a.(*corev1.ConfigMapEnvSource), b.(*core.ConfigMapEnvSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ConfigMapEnvSource)(nil), (*corev1.ConfigMapEnvSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ConfigMapEnvSource_To_v1_ConfigMapEnvSource(a.(*core.ConfigMapEnvSource), b.(*corev1.ConfigMapEnvSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ConfigMapKeySelector)(nil), (*core.ConfigMapKeySelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ConfigMapKeySelector_To_core_ConfigMapKeySelector(a.(*corev1.ConfigMapKeySelector), b.(*core.ConfigMapKeySelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ConfigMapKeySelector)(nil), (*corev1.ConfigMapKeySelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(a.(*core.ConfigMapKeySelector), b.(*corev1.ConfigMapKeySelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ConfigMapList)(nil), (*core.ConfigMapList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ConfigMapList_To_core_ConfigMapList(a.(*corev1.ConfigMapList), b.(*core.ConfigMapList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ConfigMapList)(nil), (*corev1.ConfigMapList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ConfigMapList_To_v1_ConfigMapList(a.(*core.ConfigMapList), b.(*corev1.ConfigMapList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ConfigMapNodeConfigSource)(nil), (*core.ConfigMapNodeConfigSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ConfigMapNodeConfigSource_To_core_ConfigMapNodeConfigSource(a.(*corev1.ConfigMapNodeConfigSource), b.(*core.ConfigMapNodeConfigSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ConfigMapNodeConfigSource)(nil), (*corev1.ConfigMapNodeConfigSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ConfigMapNodeConfigSource_To_v1_ConfigMapNodeConfigSource(a.(*core.ConfigMapNodeConfigSource), b.(*corev1.ConfigMapNodeConfigSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ConfigMapProjection)(nil), (*core.ConfigMapProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ConfigMapProjection_To_core_ConfigMapProjection(a.(*corev1.ConfigMapProjection), b.(*core.ConfigMapProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ConfigMapProjection)(nil), (*corev1.ConfigMapProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ConfigMapProjection_To_v1_ConfigMapProjection(a.(*core.ConfigMapProjection), b.(*corev1.ConfigMapProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ConfigMapVolumeSource)(nil), (*core.ConfigMapVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ConfigMapVolumeSource_To_core_ConfigMapVolumeSource(a.(*corev1.ConfigMapVolumeSource), b.(*core.ConfigMapVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ConfigMapVolumeSource)(nil), (*corev1.ConfigMapVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(a.(*core.ConfigMapVolumeSource), b.(*corev1.ConfigMapVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Container)(nil), (*core.Container)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Container_To_core_Container(a.(*corev1.Container), b.(*core.Container), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Container)(nil), (*corev1.Container)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Container_To_v1_Container(a.(*core.Container), b.(*corev1.Container), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerExtendedResourceRequest)(nil), (*core.ContainerExtendedResourceRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerExtendedResourceRequest_To_core_ContainerExtendedResourceRequest(a.(*corev1.ContainerExtendedResourceRequest), b.(*core.ContainerExtendedResourceRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerExtendedResourceRequest)(nil), (*corev1.ContainerExtendedResourceRequest)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerExtendedResourceRequest_To_v1_ContainerExtendedResourceRequest(a.(*core.ContainerExtendedResourceRequest), b.(*corev1.ContainerExtendedResourceRequest), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerImage)(nil), (*core.ContainerImage)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerImage_To_core_ContainerImage(a.(*corev1.ContainerImage), b.(*core.ContainerImage), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerImage)(nil), (*corev1.ContainerImage)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerImage_To_v1_ContainerImage(a.(*core.ContainerImage), b.(*corev1.ContainerImage), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerPort)(nil), (*core.ContainerPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerPort_To_core_ContainerPort(a.(*corev1.ContainerPort), b.(*core.ContainerPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerPort)(nil), (*corev1.ContainerPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerPort_To_v1_ContainerPort(a.(*core.ContainerPort), b.(*corev1.ContainerPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerResizePolicy)(nil), (*core.ContainerResizePolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerResizePolicy_To_core_ContainerResizePolicy(a.(*corev1.ContainerResizePolicy), b.(*core.ContainerResizePolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerResizePolicy)(nil), (*corev1.ContainerResizePolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerResizePolicy_To_v1_ContainerResizePolicy(a.(*core.ContainerResizePolicy), b.(*corev1.ContainerResizePolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerRestartRule)(nil), (*core.ContainerRestartRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerRestartRule_To_core_ContainerRestartRule(a.(*corev1.ContainerRestartRule), b.(*core.ContainerRestartRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerRestartRule)(nil), (*corev1.ContainerRestartRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerRestartRule_To_v1_ContainerRestartRule(a.(*core.ContainerRestartRule), b.(*corev1.ContainerRestartRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerRestartRuleOnExitCodes)(nil), (*core.ContainerRestartRuleOnExitCodes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes(a.(*corev1.ContainerRestartRuleOnExitCodes), b.(*core.ContainerRestartRuleOnExitCodes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerRestartRuleOnExitCodes)(nil), (*corev1.ContainerRestartRuleOnExitCodes)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes(a.(*core.ContainerRestartRuleOnExitCodes), b.(*corev1.ContainerRestartRuleOnExitCodes), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerState)(nil), (*core.ContainerState)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerState_To_core_ContainerState(a.(*corev1.ContainerState), b.(*core.ContainerState), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerState)(nil), (*corev1.ContainerState)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerState_To_v1_ContainerState(a.(*core.ContainerState), b.(*corev1.ContainerState), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerStateRunning)(nil), (*core.ContainerStateRunning)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerStateRunning_To_core_ContainerStateRunning(a.(*corev1.ContainerStateRunning), b.(*core.ContainerStateRunning), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerStateRunning)(nil), (*corev1.ContainerStateRunning)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerStateRunning_To_v1_ContainerStateRunning(a.(*core.ContainerStateRunning), b.(*corev1.ContainerStateRunning), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerStateTerminated)(nil), (*core.ContainerStateTerminated)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerStateTerminated_To_core_ContainerStateTerminated(a.(*corev1.ContainerStateTerminated), b.(*core.ContainerStateTerminated), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerStateTerminated)(nil), (*corev1.ContainerStateTerminated)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerStateTerminated_To_v1_ContainerStateTerminated(a.(*core.ContainerStateTerminated), b.(*corev1.ContainerStateTerminated), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerStateWaiting)(nil), (*core.ContainerStateWaiting)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerStateWaiting_To_core_ContainerStateWaiting(a.(*corev1.ContainerStateWaiting), b.(*core.ContainerStateWaiting), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerStateWaiting)(nil), (*corev1.ContainerStateWaiting)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerStateWaiting_To_v1_ContainerStateWaiting(a.(*core.ContainerStateWaiting), b.(*corev1.ContainerStateWaiting), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerStatus)(nil), (*core.ContainerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerStatus_To_core_ContainerStatus(a.(*corev1.ContainerStatus), b.(*core.ContainerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerStatus)(nil), (*corev1.ContainerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerStatus_To_v1_ContainerStatus(a.(*core.ContainerStatus), b.(*corev1.ContainerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ContainerUser)(nil), (*core.ContainerUser)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ContainerUser_To_core_ContainerUser(a.(*corev1.ContainerUser), b.(*core.ContainerUser), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ContainerUser)(nil), (*corev1.ContainerUser)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ContainerUser_To_v1_ContainerUser(a.(*core.ContainerUser), b.(*corev1.ContainerUser), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.DaemonEndpoint)(nil), (*core.DaemonEndpoint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DaemonEndpoint_To_core_DaemonEndpoint(a.(*corev1.DaemonEndpoint), b.(*core.DaemonEndpoint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.DaemonEndpoint)(nil), (*corev1.DaemonEndpoint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_DaemonEndpoint_To_v1_DaemonEndpoint(a.(*core.DaemonEndpoint), b.(*corev1.DaemonEndpoint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.DownwardAPIProjection)(nil), (*core.DownwardAPIProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DownwardAPIProjection_To_core_DownwardAPIProjection(a.(*corev1.DownwardAPIProjection), b.(*core.DownwardAPIProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.DownwardAPIProjection)(nil), (*corev1.DownwardAPIProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_DownwardAPIProjection_To_v1_DownwardAPIProjection(a.(*core.DownwardAPIProjection), b.(*corev1.DownwardAPIProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.DownwardAPIVolumeFile)(nil), (*core.DownwardAPIVolumeFile)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DownwardAPIVolumeFile_To_core_DownwardAPIVolumeFile(a.(*corev1.DownwardAPIVolumeFile), b.(*core.DownwardAPIVolumeFile), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.DownwardAPIVolumeFile)(nil), (*corev1.DownwardAPIVolumeFile)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(a.(*core.DownwardAPIVolumeFile), b.(*corev1.DownwardAPIVolumeFile), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.DownwardAPIVolumeSource)(nil), (*core.DownwardAPIVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_DownwardAPIVolumeSource_To_core_DownwardAPIVolumeSource(a.(*corev1.DownwardAPIVolumeSource), b.(*core.DownwardAPIVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.DownwardAPIVolumeSource)(nil), (*corev1.DownwardAPIVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(a.(*core.DownwardAPIVolumeSource), b.(*corev1.DownwardAPIVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EmptyDirVolumeSource)(nil), (*core.EmptyDirVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EmptyDirVolumeSource_To_core_EmptyDirVolumeSource(a.(*corev1.EmptyDirVolumeSource), b.(*core.EmptyDirVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EmptyDirVolumeSource)(nil), (*corev1.EmptyDirVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(a.(*core.EmptyDirVolumeSource), b.(*corev1.EmptyDirVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EndpointAddress)(nil), (*core.EndpointAddress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointAddress_To_core_EndpointAddress(a.(*corev1.EndpointAddress), b.(*core.EndpointAddress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EndpointAddress)(nil), (*corev1.EndpointAddress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EndpointAddress_To_v1_EndpointAddress(a.(*core.EndpointAddress), b.(*corev1.EndpointAddress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EndpointPort)(nil), (*core.EndpointPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointPort_To_core_EndpointPort(a.(*corev1.EndpointPort), b.(*core.EndpointPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EndpointPort)(nil), (*corev1.EndpointPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EndpointPort_To_v1_EndpointPort(a.(*core.EndpointPort), b.(*corev1.EndpointPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EndpointSubset)(nil), (*core.EndpointSubset)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointSubset_To_core_EndpointSubset(a.(*corev1.EndpointSubset), b.(*core.EndpointSubset), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EndpointSubset)(nil), (*corev1.EndpointSubset)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EndpointSubset_To_v1_EndpointSubset(a.(*core.EndpointSubset), b.(*corev1.EndpointSubset), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Endpoints)(nil), (*core.Endpoints)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Endpoints_To_core_Endpoints(a.(*corev1.Endpoints), b.(*core.Endpoints), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Endpoints)(nil), (*corev1.Endpoints)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Endpoints_To_v1_Endpoints(a.(*core.Endpoints), b.(*corev1.Endpoints), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EndpointsList)(nil), (*core.EndpointsList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointsList_To_core_EndpointsList(a.(*corev1.EndpointsList), b.(*core.EndpointsList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EndpointsList)(nil), (*corev1.EndpointsList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EndpointsList_To_v1_EndpointsList(a.(*core.EndpointsList), b.(*corev1.EndpointsList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EnvFromSource)(nil), (*core.EnvFromSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EnvFromSource_To_core_EnvFromSource(a.(*corev1.EnvFromSource), b.(*core.EnvFromSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EnvFromSource)(nil), (*corev1.EnvFromSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EnvFromSource_To_v1_EnvFromSource(a.(*core.EnvFromSource), b.(*corev1.EnvFromSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EnvVar)(nil), (*core.EnvVar)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EnvVar_To_core_EnvVar(a.(*corev1.EnvVar), b.(*core.EnvVar), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EnvVar)(nil), (*corev1.EnvVar)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EnvVar_To_v1_EnvVar(a.(*core.EnvVar), b.(*corev1.EnvVar), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EnvVarSource)(nil), (*core.EnvVarSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EnvVarSource_To_core_EnvVarSource(a.(*corev1.EnvVarSource), b.(*core.EnvVarSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EnvVarSource)(nil), (*corev1.EnvVarSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EnvVarSource_To_v1_EnvVarSource(a.(*core.EnvVarSource), b.(*corev1.EnvVarSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EphemeralContainer)(nil), (*core.EphemeralContainer)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EphemeralContainer_To_core_EphemeralContainer(a.(*corev1.EphemeralContainer), b.(*core.EphemeralContainer), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EphemeralContainer)(nil), (*corev1.EphemeralContainer)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EphemeralContainer_To_v1_EphemeralContainer(a.(*core.EphemeralContainer), b.(*corev1.EphemeralContainer), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EphemeralContainerCommon)(nil), (*core.EphemeralContainerCommon)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EphemeralContainerCommon_To_core_EphemeralContainerCommon(a.(*corev1.EphemeralContainerCommon), b.(*core.EphemeralContainerCommon), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EphemeralContainerCommon)(nil), (*corev1.EphemeralContainerCommon)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EphemeralContainerCommon_To_v1_EphemeralContainerCommon(a.(*core.EphemeralContainerCommon), b.(*corev1.EphemeralContainerCommon), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EphemeralVolumeSource)(nil), (*core.EphemeralVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EphemeralVolumeSource_To_core_EphemeralVolumeSource(a.(*corev1.EphemeralVolumeSource), b.(*core.EphemeralVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EphemeralVolumeSource)(nil), (*corev1.EphemeralVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EphemeralVolumeSource_To_v1_EphemeralVolumeSource(a.(*core.EphemeralVolumeSource), b.(*corev1.EphemeralVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Event)(nil), (*core.Event)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Event_To_core_Event(a.(*corev1.Event), b.(*core.Event), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Event)(nil), (*corev1.Event)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Event_To_v1_Event(a.(*core.Event), b.(*corev1.Event), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EventList)(nil), (*core.EventList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EventList_To_core_EventList(a.(*corev1.EventList), b.(*core.EventList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EventList)(nil), (*corev1.EventList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EventList_To_v1_EventList(a.(*core.EventList), b.(*corev1.EventList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EventSeries)(nil), (*core.EventSeries)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EventSeries_To_core_EventSeries(a.(*corev1.EventSeries), b.(*core.EventSeries), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EventSeries)(nil), (*corev1.EventSeries)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EventSeries_To_v1_EventSeries(a.(*core.EventSeries), b.(*corev1.EventSeries), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.EventSource)(nil), (*core.EventSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EventSource_To_core_EventSource(a.(*corev1.EventSource), b.(*core.EventSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EventSource)(nil), (*corev1.EventSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EventSource_To_v1_EventSource(a.(*core.EventSource), b.(*corev1.EventSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ExecAction)(nil), (*core.ExecAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ExecAction_To_core_ExecAction(a.(*corev1.ExecAction), b.(*core.ExecAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ExecAction)(nil), (*corev1.ExecAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ExecAction_To_v1_ExecAction(a.(*core.ExecAction), b.(*corev1.ExecAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.FCVolumeSource)(nil), (*core.FCVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FCVolumeSource_To_core_FCVolumeSource(a.(*corev1.FCVolumeSource), b.(*core.FCVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.FCVolumeSource)(nil), (*corev1.FCVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_FCVolumeSource_To_v1_FCVolumeSource(a.(*core.FCVolumeSource), b.(*corev1.FCVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.FileKeySelector)(nil), (*core.FileKeySelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FileKeySelector_To_core_FileKeySelector(a.(*corev1.FileKeySelector), b.(*core.FileKeySelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.FileKeySelector)(nil), (*corev1.FileKeySelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_FileKeySelector_To_v1_FileKeySelector(a.(*core.FileKeySelector), b.(*corev1.FileKeySelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.FlexPersistentVolumeSource)(nil), (*core.FlexPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlexPersistentVolumeSource_To_core_FlexPersistentVolumeSource(a.(*corev1.FlexPersistentVolumeSource), b.(*core.FlexPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.FlexPersistentVolumeSource)(nil), (*corev1.FlexPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_FlexPersistentVolumeSource_To_v1_FlexPersistentVolumeSource(a.(*core.FlexPersistentVolumeSource), b.(*corev1.FlexPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.FlexVolumeSource)(nil), (*core.FlexVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlexVolumeSource_To_core_FlexVolumeSource(a.(*corev1.FlexVolumeSource), b.(*core.FlexVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.FlexVolumeSource)(nil), (*corev1.FlexVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_FlexVolumeSource_To_v1_FlexVolumeSource(a.(*core.FlexVolumeSource), b.(*corev1.FlexVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.FlockerVolumeSource)(nil), (*core.FlockerVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlockerVolumeSource_To_core_FlockerVolumeSource(a.(*corev1.FlockerVolumeSource), b.(*core.FlockerVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.FlockerVolumeSource)(nil), (*corev1.FlockerVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_FlockerVolumeSource_To_v1_FlockerVolumeSource(a.(*core.FlockerVolumeSource), b.(*corev1.FlockerVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.GCEPersistentDiskVolumeSource)(nil), (*core.GCEPersistentDiskVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_GCEPersistentDiskVolumeSource_To_core_GCEPersistentDiskVolumeSource(a.(*corev1.GCEPersistentDiskVolumeSource), b.(*core.GCEPersistentDiskVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.GCEPersistentDiskVolumeSource)(nil), (*corev1.GCEPersistentDiskVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(a.(*core.GCEPersistentDiskVolumeSource), b.(*corev1.GCEPersistentDiskVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.GRPCAction)(nil), (*core.GRPCAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_GRPCAction_To_core_GRPCAction(a.(*corev1.GRPCAction), b.(*core.GRPCAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.GRPCAction)(nil), (*corev1.GRPCAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_GRPCAction_To_v1_GRPCAction(a.(*core.GRPCAction), b.(*corev1.GRPCAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.GitRepoVolumeSource)(nil), (*core.GitRepoVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_GitRepoVolumeSource_To_core_GitRepoVolumeSource(a.(*corev1.GitRepoVolumeSource), b.(*core.GitRepoVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.GitRepoVolumeSource)(nil), (*corev1.GitRepoVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(a.(*core.GitRepoVolumeSource), b.(*corev1.GitRepoVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.GlusterfsPersistentVolumeSource)(nil), (*core.GlusterfsPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_GlusterfsPersistentVolumeSource_To_core_GlusterfsPersistentVolumeSource(a.(*corev1.GlusterfsPersistentVolumeSource), b.(*core.GlusterfsPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.GlusterfsPersistentVolumeSource)(nil), (*corev1.GlusterfsPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_GlusterfsPersistentVolumeSource_To_v1_GlusterfsPersistentVolumeSource(a.(*core.GlusterfsPersistentVolumeSource), b.(*corev1.GlusterfsPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.GlusterfsVolumeSource)(nil), (*core.GlusterfsVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_GlusterfsVolumeSource_To_core_GlusterfsVolumeSource(a.(*corev1.GlusterfsVolumeSource), b.(*core.GlusterfsVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.GlusterfsVolumeSource)(nil), (*corev1.GlusterfsVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(a.(*core.GlusterfsVolumeSource), b.(*corev1.GlusterfsVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.HTTPGetAction)(nil), (*core.HTTPGetAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HTTPGetAction_To_core_HTTPGetAction(a.(*corev1.HTTPGetAction), b.(*core.HTTPGetAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.HTTPGetAction)(nil), (*corev1.HTTPGetAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_HTTPGetAction_To_v1_HTTPGetAction(a.(*core.HTTPGetAction), b.(*corev1.HTTPGetAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.HTTPHeader)(nil), (*core.HTTPHeader)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HTTPHeader_To_core_HTTPHeader(a.(*corev1.HTTPHeader), b.(*core.HTTPHeader), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.HTTPHeader)(nil), (*corev1.HTTPHeader)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_HTTPHeader_To_v1_HTTPHeader(a.(*core.HTTPHeader), b.(*corev1.HTTPHeader), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.HostAlias)(nil), (*core.HostAlias)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HostAlias_To_core_HostAlias(a.(*corev1.HostAlias), b.(*core.HostAlias), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.HostAlias)(nil), (*corev1.HostAlias)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_HostAlias_To_v1_HostAlias(a.(*core.HostAlias), b.(*corev1.HostAlias), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.HostIP)(nil), (*core.HostIP)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HostIP_To_core_HostIP(a.(*corev1.HostIP), b.(*core.HostIP), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.HostIP)(nil), (*corev1.HostIP)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_HostIP_To_v1_HostIP(a.(*core.HostIP), b.(*corev1.HostIP), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.HostPathVolumeSource)(nil), (*core.HostPathVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_HostPathVolumeSource_To_core_HostPathVolumeSource(a.(*corev1.HostPathVolumeSource), b.(*core.HostPathVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.HostPathVolumeSource)(nil), (*corev1.HostPathVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_HostPathVolumeSource_To_v1_HostPathVolumeSource(a.(*core.HostPathVolumeSource), b.(*corev1.HostPathVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ISCSIPersistentVolumeSource)(nil), (*core.ISCSIPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ISCSIPersistentVolumeSource_To_core_ISCSIPersistentVolumeSource(a.(*corev1.ISCSIPersistentVolumeSource), b.(*core.ISCSIPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ISCSIPersistentVolumeSource)(nil), (*corev1.ISCSIPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ISCSIPersistentVolumeSource_To_v1_ISCSIPersistentVolumeSource(a.(*core.ISCSIPersistentVolumeSource), b.(*corev1.ISCSIPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ISCSIVolumeSource)(nil), (*core.ISCSIVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ISCSIVolumeSource_To_core_ISCSIVolumeSource(a.(*corev1.ISCSIVolumeSource), b.(*core.ISCSIVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ISCSIVolumeSource)(nil), (*corev1.ISCSIVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(a.(*core.ISCSIVolumeSource), b.(*corev1.ISCSIVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ImageVolumeSource)(nil), (*core.ImageVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ImageVolumeSource_To_core_ImageVolumeSource(a.(*corev1.ImageVolumeSource), b.(*core.ImageVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ImageVolumeSource)(nil), (*corev1.ImageVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ImageVolumeSource_To_v1_ImageVolumeSource(a.(*core.ImageVolumeSource), b.(*corev1.ImageVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.KeyToPath)(nil), (*core.KeyToPath)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_KeyToPath_To_core_KeyToPath(a.(*corev1.KeyToPath), b.(*core.KeyToPath), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.KeyToPath)(nil), (*corev1.KeyToPath)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_KeyToPath_To_v1_KeyToPath(a.(*core.KeyToPath), b.(*corev1.KeyToPath), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Lifecycle)(nil), (*core.Lifecycle)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Lifecycle_To_core_Lifecycle(a.(*corev1.Lifecycle), b.(*core.Lifecycle), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Lifecycle)(nil), (*corev1.Lifecycle)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Lifecycle_To_v1_Lifecycle(a.(*core.Lifecycle), b.(*corev1.Lifecycle), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LifecycleHandler)(nil), (*core.LifecycleHandler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LifecycleHandler_To_core_LifecycleHandler(a.(*corev1.LifecycleHandler), b.(*core.LifecycleHandler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LifecycleHandler)(nil), (*corev1.LifecycleHandler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LifecycleHandler_To_v1_LifecycleHandler(a.(*core.LifecycleHandler), b.(*corev1.LifecycleHandler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LimitRange)(nil), (*core.LimitRange)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LimitRange_To_core_LimitRange(a.(*corev1.LimitRange), b.(*core.LimitRange), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LimitRange)(nil), (*corev1.LimitRange)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LimitRange_To_v1_LimitRange(a.(*core.LimitRange), b.(*corev1.LimitRange), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LimitRangeItem)(nil), (*core.LimitRangeItem)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LimitRangeItem_To_core_LimitRangeItem(a.(*corev1.LimitRangeItem), b.(*core.LimitRangeItem), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LimitRangeItem)(nil), (*corev1.LimitRangeItem)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LimitRangeItem_To_v1_LimitRangeItem(a.(*core.LimitRangeItem), b.(*corev1.LimitRangeItem), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LimitRangeList)(nil), (*core.LimitRangeList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LimitRangeList_To_core_LimitRangeList(a.(*corev1.LimitRangeList), b.(*core.LimitRangeList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LimitRangeList)(nil), (*corev1.LimitRangeList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LimitRangeList_To_v1_LimitRangeList(a.(*core.LimitRangeList), b.(*corev1.LimitRangeList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LimitRangeSpec)(nil), (*core.LimitRangeSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LimitRangeSpec_To_core_LimitRangeSpec(a.(*corev1.LimitRangeSpec), b.(*core.LimitRangeSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LimitRangeSpec)(nil), (*corev1.LimitRangeSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LimitRangeSpec_To_v1_LimitRangeSpec(a.(*core.LimitRangeSpec), b.(*corev1.LimitRangeSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LinuxContainerUser)(nil), (*core.LinuxContainerUser)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LinuxContainerUser_To_core_LinuxContainerUser(a.(*corev1.LinuxContainerUser), b.(*core.LinuxContainerUser), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LinuxContainerUser)(nil), (*corev1.LinuxContainerUser)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LinuxContainerUser_To_v1_LinuxContainerUser(a.(*core.LinuxContainerUser), b.(*corev1.LinuxContainerUser), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.List)(nil), (*core.List)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_List_To_core_List(a.(*corev1.List), b.(*core.List), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.List)(nil), (*corev1.List)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_List_To_v1_List(a.(*core.List), b.(*corev1.List), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LoadBalancerIngress)(nil), (*core.LoadBalancerIngress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LoadBalancerIngress_To_core_LoadBalancerIngress(a.(*corev1.LoadBalancerIngress), b.(*core.LoadBalancerIngress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LoadBalancerIngress)(nil), (*corev1.LoadBalancerIngress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LoadBalancerIngress_To_v1_LoadBalancerIngress(a.(*core.LoadBalancerIngress), b.(*corev1.LoadBalancerIngress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LoadBalancerStatus)(nil), (*core.LoadBalancerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus(a.(*corev1.LoadBalancerStatus), b.(*core.LoadBalancerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LoadBalancerStatus)(nil), (*corev1.LoadBalancerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus(a.(*core.LoadBalancerStatus), b.(*corev1.LoadBalancerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LocalObjectReference)(nil), (*core.LocalObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LocalObjectReference_To_core_LocalObjectReference(a.(*corev1.LocalObjectReference), b.(*core.LocalObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LocalObjectReference)(nil), (*corev1.LocalObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LocalObjectReference_To_v1_LocalObjectReference(a.(*core.LocalObjectReference), b.(*corev1.LocalObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.LocalVolumeSource)(nil), (*core.LocalVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LocalVolumeSource_To_core_LocalVolumeSource(a.(*corev1.LocalVolumeSource), b.(*core.LocalVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.LocalVolumeSource)(nil), (*corev1.LocalVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_LocalVolumeSource_To_v1_LocalVolumeSource(a.(*core.LocalVolumeSource), b.(*corev1.LocalVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ModifyVolumeStatus)(nil), (*core.ModifyVolumeStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ModifyVolumeStatus_To_core_ModifyVolumeStatus(a.(*corev1.ModifyVolumeStatus), b.(*core.ModifyVolumeStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ModifyVolumeStatus)(nil), (*corev1.ModifyVolumeStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ModifyVolumeStatus_To_v1_ModifyVolumeStatus(a.(*core.ModifyVolumeStatus), b.(*corev1.ModifyVolumeStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NFSVolumeSource)(nil), (*core.NFSVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NFSVolumeSource_To_core_NFSVolumeSource(a.(*corev1.NFSVolumeSource), b.(*core.NFSVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NFSVolumeSource)(nil), (*corev1.NFSVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NFSVolumeSource_To_v1_NFSVolumeSource(a.(*core.NFSVolumeSource), b.(*corev1.NFSVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Namespace)(nil), (*core.Namespace)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Namespace_To_core_Namespace(a.(*corev1.Namespace), b.(*core.Namespace), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Namespace)(nil), (*corev1.Namespace)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Namespace_To_v1_Namespace(a.(*core.Namespace), b.(*corev1.Namespace), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NamespaceCondition)(nil), (*core.NamespaceCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NamespaceCondition_To_core_NamespaceCondition(a.(*corev1.NamespaceCondition), b.(*core.NamespaceCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NamespaceCondition)(nil), (*corev1.NamespaceCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NamespaceCondition_To_v1_NamespaceCondition(a.(*core.NamespaceCondition), b.(*corev1.NamespaceCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NamespaceList)(nil), (*core.NamespaceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NamespaceList_To_core_NamespaceList(a.(*corev1.NamespaceList), b.(*core.NamespaceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NamespaceList)(nil), (*corev1.NamespaceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NamespaceList_To_v1_NamespaceList(a.(*core.NamespaceList), b.(*corev1.NamespaceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NamespaceSpec)(nil), (*core.NamespaceSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NamespaceSpec_To_core_NamespaceSpec(a.(*corev1.NamespaceSpec), b.(*core.NamespaceSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NamespaceSpec)(nil), (*corev1.NamespaceSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NamespaceSpec_To_v1_NamespaceSpec(a.(*core.NamespaceSpec), b.(*corev1.NamespaceSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NamespaceStatus)(nil), (*core.NamespaceStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NamespaceStatus_To_core_NamespaceStatus(a.(*corev1.NamespaceStatus), b.(*core.NamespaceStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NamespaceStatus)(nil), (*corev1.NamespaceStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NamespaceStatus_To_v1_NamespaceStatus(a.(*core.NamespaceStatus), b.(*corev1.NamespaceStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Node)(nil), (*core.Node)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Node_To_core_Node(a.(*corev1.Node), b.(*core.Node), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Node)(nil), (*corev1.Node)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Node_To_v1_Node(a.(*core.Node), b.(*corev1.Node), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeAddress)(nil), (*core.NodeAddress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeAddress_To_core_NodeAddress(a.(*corev1.NodeAddress), b.(*core.NodeAddress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeAddress)(nil), (*corev1.NodeAddress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeAddress_To_v1_NodeAddress(a.(*core.NodeAddress), b.(*corev1.NodeAddress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeAffinity)(nil), (*core.NodeAffinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeAffinity_To_core_NodeAffinity(a.(*corev1.NodeAffinity), b.(*core.NodeAffinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeAffinity)(nil), (*corev1.NodeAffinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeAffinity_To_v1_NodeAffinity(a.(*core.NodeAffinity), b.(*corev1.NodeAffinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeCondition)(nil), (*core.NodeCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeCondition_To_core_NodeCondition(a.(*corev1.NodeCondition), b.(*core.NodeCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeCondition)(nil), (*corev1.NodeCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeCondition_To_v1_NodeCondition(a.(*core.NodeCondition), b.(*corev1.NodeCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeConfigSource)(nil), (*core.NodeConfigSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeConfigSource_To_core_NodeConfigSource(a.(*corev1.NodeConfigSource), b.(*core.NodeConfigSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeConfigSource)(nil), (*corev1.NodeConfigSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeConfigSource_To_v1_NodeConfigSource(a.(*core.NodeConfigSource), b.(*corev1.NodeConfigSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeConfigStatus)(nil), (*core.NodeConfigStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeConfigStatus_To_core_NodeConfigStatus(a.(*corev1.NodeConfigStatus), b.(*core.NodeConfigStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeConfigStatus)(nil), (*corev1.NodeConfigStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeConfigStatus_To_v1_NodeConfigStatus(a.(*core.NodeConfigStatus), b.(*corev1.NodeConfigStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeDaemonEndpoints)(nil), (*core.NodeDaemonEndpoints)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeDaemonEndpoints_To_core_NodeDaemonEndpoints(a.(*corev1.NodeDaemonEndpoints), b.(*core.NodeDaemonEndpoints), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeDaemonEndpoints)(nil), (*corev1.NodeDaemonEndpoints)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(a.(*core.NodeDaemonEndpoints), b.(*corev1.NodeDaemonEndpoints), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeFeatures)(nil), (*core.NodeFeatures)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeFeatures_To_core_NodeFeatures(a.(*corev1.NodeFeatures), b.(*core.NodeFeatures), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeFeatures)(nil), (*corev1.NodeFeatures)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeFeatures_To_v1_NodeFeatures(a.(*core.NodeFeatures), b.(*corev1.NodeFeatures), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeList)(nil), (*core.NodeList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeList_To_core_NodeList(a.(*corev1.NodeList), b.(*core.NodeList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeList)(nil), (*corev1.NodeList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeList_To_v1_NodeList(a.(*core.NodeList), b.(*corev1.NodeList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeProxyOptions)(nil), (*core.NodeProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeProxyOptions_To_core_NodeProxyOptions(a.(*corev1.NodeProxyOptions), b.(*core.NodeProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeProxyOptions)(nil), (*corev1.NodeProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeProxyOptions_To_v1_NodeProxyOptions(a.(*core.NodeProxyOptions), b.(*corev1.NodeProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeRuntimeHandler)(nil), (*core.NodeRuntimeHandler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeRuntimeHandler_To_core_NodeRuntimeHandler(a.(*corev1.NodeRuntimeHandler), b.(*core.NodeRuntimeHandler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeRuntimeHandler)(nil), (*corev1.NodeRuntimeHandler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeRuntimeHandler_To_v1_NodeRuntimeHandler(a.(*core.NodeRuntimeHandler), b.(*corev1.NodeRuntimeHandler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeRuntimeHandlerFeatures)(nil), (*core.NodeRuntimeHandlerFeatures)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeRuntimeHandlerFeatures_To_core_NodeRuntimeHandlerFeatures(a.(*corev1.NodeRuntimeHandlerFeatures), b.(*core.NodeRuntimeHandlerFeatures), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeRuntimeHandlerFeatures)(nil), (*corev1.NodeRuntimeHandlerFeatures)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeRuntimeHandlerFeatures_To_v1_NodeRuntimeHandlerFeatures(a.(*core.NodeRuntimeHandlerFeatures), b.(*corev1.NodeRuntimeHandlerFeatures), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeSelector)(nil), (*core.NodeSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeSelector_To_core_NodeSelector(a.(*corev1.NodeSelector), b.(*core.NodeSelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeSelector)(nil), (*corev1.NodeSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeSelector_To_v1_NodeSelector(a.(*core.NodeSelector), b.(*corev1.NodeSelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeSelectorRequirement)(nil), (*core.NodeSelectorRequirement)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeSelectorRequirement_To_core_NodeSelectorRequirement(a.(*corev1.NodeSelectorRequirement), b.(*core.NodeSelectorRequirement), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeSelectorRequirement)(nil), (*corev1.NodeSelectorRequirement)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeSelectorRequirement_To_v1_NodeSelectorRequirement(a.(*core.NodeSelectorRequirement), b.(*corev1.NodeSelectorRequirement), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeSelectorTerm)(nil), (*core.NodeSelectorTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeSelectorTerm_To_core_NodeSelectorTerm(a.(*corev1.NodeSelectorTerm), b.(*core.NodeSelectorTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeSelectorTerm)(nil), (*corev1.NodeSelectorTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeSelectorTerm_To_v1_NodeSelectorTerm(a.(*core.NodeSelectorTerm), b.(*corev1.NodeSelectorTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeStatus)(nil), (*core.NodeStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeStatus_To_core_NodeStatus(a.(*corev1.NodeStatus), b.(*core.NodeStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeStatus)(nil), (*corev1.NodeStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeStatus_To_v1_NodeStatus(a.(*core.NodeStatus), b.(*corev1.NodeStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeSwapStatus)(nil), (*core.NodeSwapStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeSwapStatus_To_core_NodeSwapStatus(a.(*corev1.NodeSwapStatus), b.(*core.NodeSwapStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeSwapStatus)(nil), (*corev1.NodeSwapStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeSwapStatus_To_v1_NodeSwapStatus(a.(*core.NodeSwapStatus), b.(*corev1.NodeSwapStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.NodeSystemInfo)(nil), (*core.NodeSystemInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeSystemInfo_To_core_NodeSystemInfo(a.(*corev1.NodeSystemInfo), b.(*core.NodeSystemInfo), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.NodeSystemInfo)(nil), (*corev1.NodeSystemInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeSystemInfo_To_v1_NodeSystemInfo(a.(*core.NodeSystemInfo), b.(*corev1.NodeSystemInfo), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ObjectFieldSelector)(nil), (*core.ObjectFieldSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ObjectFieldSelector_To_core_ObjectFieldSelector(a.(*corev1.ObjectFieldSelector), b.(*core.ObjectFieldSelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ObjectFieldSelector)(nil), (*corev1.ObjectFieldSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ObjectFieldSelector_To_v1_ObjectFieldSelector(a.(*core.ObjectFieldSelector), b.(*corev1.ObjectFieldSelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ObjectReference)(nil), (*core.ObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ObjectReference_To_core_ObjectReference(a.(*corev1.ObjectReference), b.(*core.ObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ObjectReference)(nil), (*corev1.ObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ObjectReference_To_v1_ObjectReference(a.(*core.ObjectReference), b.(*corev1.ObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolume)(nil), (*core.PersistentVolume)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolume_To_core_PersistentVolume(a.(*corev1.PersistentVolume), b.(*core.PersistentVolume), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolume)(nil), (*corev1.PersistentVolume)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolume_To_v1_PersistentVolume(a.(*core.PersistentVolume), b.(*corev1.PersistentVolume), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeClaim)(nil), (*core.PersistentVolumeClaim)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeClaim_To_core_PersistentVolumeClaim(a.(*corev1.PersistentVolumeClaim), b.(*core.PersistentVolumeClaim), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeClaim)(nil), (*corev1.PersistentVolumeClaim)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(a.(*core.PersistentVolumeClaim), b.(*corev1.PersistentVolumeClaim), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeClaimCondition)(nil), (*core.PersistentVolumeClaimCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeClaimCondition_To_core_PersistentVolumeClaimCondition(a.(*corev1.PersistentVolumeClaimCondition), b.(*core.PersistentVolumeClaimCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeClaimCondition)(nil), (*corev1.PersistentVolumeClaimCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeClaimCondition_To_v1_PersistentVolumeClaimCondition(a.(*core.PersistentVolumeClaimCondition), b.(*corev1.PersistentVolumeClaimCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeClaimList)(nil), (*core.PersistentVolumeClaimList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeClaimList_To_core_PersistentVolumeClaimList(a.(*corev1.PersistentVolumeClaimList), b.(*core.PersistentVolumeClaimList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeClaimList)(nil), (*corev1.PersistentVolumeClaimList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList(a.(*core.PersistentVolumeClaimList), b.(*corev1.PersistentVolumeClaimList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeClaimSpec)(nil), (*core.PersistentVolumeClaimSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeClaimSpec_To_core_PersistentVolumeClaimSpec(a.(*corev1.PersistentVolumeClaimSpec), b.(*core.PersistentVolumeClaimSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeClaimSpec)(nil), (*corev1.PersistentVolumeClaimSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(a.(*core.PersistentVolumeClaimSpec), b.(*corev1.PersistentVolumeClaimSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeClaimStatus)(nil), (*core.PersistentVolumeClaimStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeClaimStatus_To_core_PersistentVolumeClaimStatus(a.(*corev1.PersistentVolumeClaimStatus), b.(*core.PersistentVolumeClaimStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeClaimStatus)(nil), (*corev1.PersistentVolumeClaimStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(a.(*core.PersistentVolumeClaimStatus), b.(*corev1.PersistentVolumeClaimStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeClaimTemplate)(nil), (*core.PersistentVolumeClaimTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeClaimTemplate_To_core_PersistentVolumeClaimTemplate(a.(*corev1.PersistentVolumeClaimTemplate), b.(*core.PersistentVolumeClaimTemplate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeClaimTemplate)(nil), (*corev1.PersistentVolumeClaimTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeClaimTemplate_To_v1_PersistentVolumeClaimTemplate(a.(*core.PersistentVolumeClaimTemplate), b.(*corev1.PersistentVolumeClaimTemplate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeClaimVolumeSource)(nil), (*core.PersistentVolumeClaimVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeClaimVolumeSource_To_core_PersistentVolumeClaimVolumeSource(a.(*corev1.PersistentVolumeClaimVolumeSource), b.(*core.PersistentVolumeClaimVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeClaimVolumeSource)(nil), (*corev1.PersistentVolumeClaimVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(a.(*core.PersistentVolumeClaimVolumeSource), b.(*corev1.PersistentVolumeClaimVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeList)(nil), (*core.PersistentVolumeList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeList_To_core_PersistentVolumeList(a.(*corev1.PersistentVolumeList), b.(*core.PersistentVolumeList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeList)(nil), (*corev1.PersistentVolumeList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeList_To_v1_PersistentVolumeList(a.(*core.PersistentVolumeList), b.(*corev1.PersistentVolumeList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeSource)(nil), (*core.PersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeSource_To_core_PersistentVolumeSource(a.(*corev1.PersistentVolumeSource), b.(*core.PersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeSource)(nil), (*corev1.PersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeSource_To_v1_PersistentVolumeSource(a.(*core.PersistentVolumeSource), b.(*corev1.PersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PersistentVolumeStatus)(nil), (*core.PersistentVolumeStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeStatus_To_core_PersistentVolumeStatus(a.(*corev1.PersistentVolumeStatus), b.(*core.PersistentVolumeStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PersistentVolumeStatus)(nil), (*corev1.PersistentVolumeStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(a.(*core.PersistentVolumeStatus), b.(*corev1.PersistentVolumeStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PhotonPersistentDiskVolumeSource)(nil), (*core.PhotonPersistentDiskVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PhotonPersistentDiskVolumeSource_To_core_PhotonPersistentDiskVolumeSource(a.(*corev1.PhotonPersistentDiskVolumeSource), b.(*core.PhotonPersistentDiskVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PhotonPersistentDiskVolumeSource)(nil), (*corev1.PhotonPersistentDiskVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PhotonPersistentDiskVolumeSource_To_v1_PhotonPersistentDiskVolumeSource(a.(*core.PhotonPersistentDiskVolumeSource), b.(*corev1.PhotonPersistentDiskVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodAffinity)(nil), (*core.PodAffinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodAffinity_To_core_PodAffinity(a.(*corev1.PodAffinity), b.(*core.PodAffinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodAffinity)(nil), (*corev1.PodAffinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodAffinity_To_v1_PodAffinity(a.(*core.PodAffinity), b.(*corev1.PodAffinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodAffinityTerm)(nil), (*core.PodAffinityTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodAffinityTerm_To_core_PodAffinityTerm(a.(*corev1.PodAffinityTerm), b.(*core.PodAffinityTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodAffinityTerm)(nil), (*corev1.PodAffinityTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodAffinityTerm_To_v1_PodAffinityTerm(a.(*core.PodAffinityTerm), b.(*corev1.PodAffinityTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodAntiAffinity)(nil), (*core.PodAntiAffinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodAntiAffinity_To_core_PodAntiAffinity(a.(*corev1.PodAntiAffinity), b.(*core.PodAntiAffinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodAntiAffinity)(nil), (*corev1.PodAntiAffinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodAntiAffinity_To_v1_PodAntiAffinity(a.(*core.PodAntiAffinity), b.(*corev1.PodAntiAffinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodAttachOptions)(nil), (*core.PodAttachOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodAttachOptions_To_core_PodAttachOptions(a.(*corev1.PodAttachOptions), b.(*core.PodAttachOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodAttachOptions)(nil), (*corev1.PodAttachOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodAttachOptions_To_v1_PodAttachOptions(a.(*core.PodAttachOptions), b.(*corev1.PodAttachOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodCertificateProjection)(nil), (*core.PodCertificateProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodCertificateProjection_To_core_PodCertificateProjection(a.(*corev1.PodCertificateProjection), b.(*core.PodCertificateProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodCertificateProjection)(nil), (*corev1.PodCertificateProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodCertificateProjection_To_v1_PodCertificateProjection(a.(*core.PodCertificateProjection), b.(*corev1.PodCertificateProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodCondition)(nil), (*core.PodCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodCondition_To_core_PodCondition(a.(*corev1.PodCondition), b.(*core.PodCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodCondition)(nil), (*corev1.PodCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodCondition_To_v1_PodCondition(a.(*core.PodCondition), b.(*corev1.PodCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodDNSConfig)(nil), (*core.PodDNSConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodDNSConfig_To_core_PodDNSConfig(a.(*corev1.PodDNSConfig), b.(*core.PodDNSConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodDNSConfig)(nil), (*corev1.PodDNSConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodDNSConfig_To_v1_PodDNSConfig(a.(*core.PodDNSConfig), b.(*corev1.PodDNSConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodDNSConfigOption)(nil), (*core.PodDNSConfigOption)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodDNSConfigOption_To_core_PodDNSConfigOption(a.(*corev1.PodDNSConfigOption), b.(*core.PodDNSConfigOption), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodDNSConfigOption)(nil), (*corev1.PodDNSConfigOption)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodDNSConfigOption_To_v1_PodDNSConfigOption(a.(*core.PodDNSConfigOption), b.(*corev1.PodDNSConfigOption), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodExecOptions)(nil), (*core.PodExecOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodExecOptions_To_core_PodExecOptions(a.(*corev1.PodExecOptions), b.(*core.PodExecOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodExecOptions)(nil), (*corev1.PodExecOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodExecOptions_To_v1_PodExecOptions(a.(*core.PodExecOptions), b.(*corev1.PodExecOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodExtendedResourceClaimStatus)(nil), (*core.PodExtendedResourceClaimStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodExtendedResourceClaimStatus_To_core_PodExtendedResourceClaimStatus(a.(*corev1.PodExtendedResourceClaimStatus), b.(*core.PodExtendedResourceClaimStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodExtendedResourceClaimStatus)(nil), (*corev1.PodExtendedResourceClaimStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodExtendedResourceClaimStatus_To_v1_PodExtendedResourceClaimStatus(a.(*core.PodExtendedResourceClaimStatus), b.(*corev1.PodExtendedResourceClaimStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodIP)(nil), (*core.PodIP)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodIP_To_core_PodIP(a.(*corev1.PodIP), b.(*core.PodIP), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodIP)(nil), (*corev1.PodIP)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodIP_To_v1_PodIP(a.(*core.PodIP), b.(*corev1.PodIP), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodList)(nil), (*core.PodList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodList_To_core_PodList(a.(*corev1.PodList), b.(*core.PodList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodList)(nil), (*corev1.PodList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodList_To_v1_PodList(a.(*core.PodList), b.(*corev1.PodList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodLogOptions)(nil), (*core.PodLogOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodLogOptions_To_core_PodLogOptions(a.(*corev1.PodLogOptions), b.(*core.PodLogOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodLogOptions)(nil), (*corev1.PodLogOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodLogOptions_To_v1_PodLogOptions(a.(*core.PodLogOptions), b.(*corev1.PodLogOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodOS)(nil), (*core.PodOS)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodOS_To_core_PodOS(a.(*corev1.PodOS), b.(*core.PodOS), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodOS)(nil), (*corev1.PodOS)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodOS_To_v1_PodOS(a.(*core.PodOS), b.(*corev1.PodOS), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodPortForwardOptions)(nil), (*core.PodPortForwardOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodPortForwardOptions_To_core_PodPortForwardOptions(a.(*corev1.PodPortForwardOptions), b.(*core.PodPortForwardOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodPortForwardOptions)(nil), (*corev1.PodPortForwardOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodPortForwardOptions_To_v1_PodPortForwardOptions(a.(*core.PodPortForwardOptions), b.(*corev1.PodPortForwardOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodProxyOptions)(nil), (*core.PodProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodProxyOptions_To_core_PodProxyOptions(a.(*corev1.PodProxyOptions), b.(*core.PodProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodProxyOptions)(nil), (*corev1.PodProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodProxyOptions_To_v1_PodProxyOptions(a.(*core.PodProxyOptions), b.(*corev1.PodProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodReadinessGate)(nil), (*core.PodReadinessGate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodReadinessGate_To_core_PodReadinessGate(a.(*corev1.PodReadinessGate), b.(*core.PodReadinessGate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodReadinessGate)(nil), (*corev1.PodReadinessGate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodReadinessGate_To_v1_PodReadinessGate(a.(*core.PodReadinessGate), b.(*corev1.PodReadinessGate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodResourceClaim)(nil), (*core.PodResourceClaim)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodResourceClaim_To_core_PodResourceClaim(a.(*corev1.PodResourceClaim), b.(*core.PodResourceClaim), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodResourceClaim)(nil), (*corev1.PodResourceClaim)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodResourceClaim_To_v1_PodResourceClaim(a.(*core.PodResourceClaim), b.(*corev1.PodResourceClaim), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodResourceClaimStatus)(nil), (*core.PodResourceClaimStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodResourceClaimStatus_To_core_PodResourceClaimStatus(a.(*corev1.PodResourceClaimStatus), b.(*core.PodResourceClaimStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodResourceClaimStatus)(nil), (*corev1.PodResourceClaimStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodResourceClaimStatus_To_v1_PodResourceClaimStatus(a.(*core.PodResourceClaimStatus), b.(*corev1.PodResourceClaimStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodSchedulingGate)(nil), (*core.PodSchedulingGate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodSchedulingGate_To_core_PodSchedulingGate(a.(*corev1.PodSchedulingGate), b.(*core.PodSchedulingGate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodSchedulingGate)(nil), (*corev1.PodSchedulingGate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodSchedulingGate_To_v1_PodSchedulingGate(a.(*core.PodSchedulingGate), b.(*corev1.PodSchedulingGate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodSecurityContext)(nil), (*core.PodSecurityContext)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodSecurityContext_To_core_PodSecurityContext(a.(*corev1.PodSecurityContext), b.(*core.PodSecurityContext), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodSecurityContext)(nil), (*corev1.PodSecurityContext)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodSecurityContext_To_v1_PodSecurityContext(a.(*core.PodSecurityContext), b.(*corev1.PodSecurityContext), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodSignature)(nil), (*core.PodSignature)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodSignature_To_core_PodSignature(a.(*corev1.PodSignature), b.(*core.PodSignature), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodSignature)(nil), (*corev1.PodSignature)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodSignature_To_v1_PodSignature(a.(*core.PodSignature), b.(*corev1.PodSignature), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodStatusResult)(nil), (*core.PodStatusResult)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodStatusResult_To_core_PodStatusResult(a.(*corev1.PodStatusResult), b.(*core.PodStatusResult), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodStatusResult)(nil), (*corev1.PodStatusResult)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodStatusResult_To_v1_PodStatusResult(a.(*core.PodStatusResult), b.(*corev1.PodStatusResult), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodTemplate)(nil), (*core.PodTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodTemplate_To_core_PodTemplate(a.(*corev1.PodTemplate), b.(*core.PodTemplate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodTemplate)(nil), (*corev1.PodTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodTemplate_To_v1_PodTemplate(a.(*core.PodTemplate), b.(*corev1.PodTemplate), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PodTemplateList)(nil), (*core.PodTemplateList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodTemplateList_To_core_PodTemplateList(a.(*corev1.PodTemplateList), b.(*core.PodTemplateList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PodTemplateList)(nil), (*corev1.PodTemplateList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodTemplateList_To_v1_PodTemplateList(a.(*core.PodTemplateList), b.(*corev1.PodTemplateList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PortStatus)(nil), (*core.PortStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PortStatus_To_core_PortStatus(a.(*corev1.PortStatus), b.(*core.PortStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PortStatus)(nil), (*corev1.PortStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PortStatus_To_v1_PortStatus(a.(*core.PortStatus), b.(*corev1.PortStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PortworxVolumeSource)(nil), (*core.PortworxVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PortworxVolumeSource_To_core_PortworxVolumeSource(a.(*corev1.PortworxVolumeSource), b.(*core.PortworxVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PortworxVolumeSource)(nil), (*corev1.PortworxVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PortworxVolumeSource_To_v1_PortworxVolumeSource(a.(*core.PortworxVolumeSource), b.(*corev1.PortworxVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Preconditions)(nil), (*core.Preconditions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Preconditions_To_core_Preconditions(a.(*corev1.Preconditions), b.(*core.Preconditions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Preconditions)(nil), (*corev1.Preconditions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Preconditions_To_v1_Preconditions(a.(*core.Preconditions), b.(*corev1.Preconditions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PreferAvoidPodsEntry)(nil), (*core.PreferAvoidPodsEntry)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PreferAvoidPodsEntry_To_core_PreferAvoidPodsEntry(a.(*corev1.PreferAvoidPodsEntry), b.(*core.PreferAvoidPodsEntry), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PreferAvoidPodsEntry)(nil), (*corev1.PreferAvoidPodsEntry)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PreferAvoidPodsEntry_To_v1_PreferAvoidPodsEntry(a.(*core.PreferAvoidPodsEntry), b.(*corev1.PreferAvoidPodsEntry), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.PreferredSchedulingTerm)(nil), (*core.PreferredSchedulingTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PreferredSchedulingTerm_To_core_PreferredSchedulingTerm(a.(*corev1.PreferredSchedulingTerm), b.(*core.PreferredSchedulingTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.PreferredSchedulingTerm)(nil), (*corev1.PreferredSchedulingTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm(a.(*core.PreferredSchedulingTerm), b.(*corev1.PreferredSchedulingTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Probe)(nil), (*core.Probe)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Probe_To_core_Probe(a.(*corev1.Probe), b.(*core.Probe), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Probe)(nil), (*corev1.Probe)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Probe_To_v1_Probe(a.(*core.Probe), b.(*corev1.Probe), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ProbeHandler)(nil), (*core.ProbeHandler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ProbeHandler_To_core_ProbeHandler(a.(*corev1.ProbeHandler), b.(*core.ProbeHandler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ProbeHandler)(nil), (*corev1.ProbeHandler)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ProbeHandler_To_v1_ProbeHandler(a.(*core.ProbeHandler), b.(*corev1.ProbeHandler), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ProjectedVolumeSource)(nil), (*core.ProjectedVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ProjectedVolumeSource_To_core_ProjectedVolumeSource(a.(*corev1.ProjectedVolumeSource), b.(*core.ProjectedVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ProjectedVolumeSource)(nil), (*corev1.ProjectedVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ProjectedVolumeSource_To_v1_ProjectedVolumeSource(a.(*core.ProjectedVolumeSource), b.(*corev1.ProjectedVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.QuobyteVolumeSource)(nil), (*core.QuobyteVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_QuobyteVolumeSource_To_core_QuobyteVolumeSource(a.(*corev1.QuobyteVolumeSource), b.(*core.QuobyteVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.QuobyteVolumeSource)(nil), (*corev1.QuobyteVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_QuobyteVolumeSource_To_v1_QuobyteVolumeSource(a.(*core.QuobyteVolumeSource), b.(*corev1.QuobyteVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.RBDPersistentVolumeSource)(nil), (*core.RBDPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_RBDPersistentVolumeSource_To_core_RBDPersistentVolumeSource(a.(*corev1.RBDPersistentVolumeSource), b.(*core.RBDPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.RBDPersistentVolumeSource)(nil), (*corev1.RBDPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_RBDPersistentVolumeSource_To_v1_RBDPersistentVolumeSource(a.(*core.RBDPersistentVolumeSource), b.(*corev1.RBDPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.RBDVolumeSource)(nil), (*core.RBDVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_RBDVolumeSource_To_core_RBDVolumeSource(a.(*corev1.RBDVolumeSource), b.(*core.RBDVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.RBDVolumeSource)(nil), (*corev1.RBDVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_RBDVolumeSource_To_v1_RBDVolumeSource(a.(*core.RBDVolumeSource), b.(*corev1.RBDVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.RangeAllocation)(nil), (*core.RangeAllocation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_RangeAllocation_To_core_RangeAllocation(a.(*corev1.RangeAllocation), b.(*core.RangeAllocation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.RangeAllocation)(nil), (*corev1.RangeAllocation)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_RangeAllocation_To_v1_RangeAllocation(a.(*core.RangeAllocation), b.(*corev1.RangeAllocation), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ReplicationController)(nil), (*core.ReplicationController)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicationController_To_core_ReplicationController(a.(*corev1.ReplicationController), b.(*core.ReplicationController), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ReplicationController)(nil), (*corev1.ReplicationController)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ReplicationController_To_v1_ReplicationController(a.(*core.ReplicationController), b.(*corev1.ReplicationController), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ReplicationControllerCondition)(nil), (*core.ReplicationControllerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicationControllerCondition_To_core_ReplicationControllerCondition(a.(*corev1.ReplicationControllerCondition), b.(*core.ReplicationControllerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ReplicationControllerCondition)(nil), (*corev1.ReplicationControllerCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ReplicationControllerCondition_To_v1_ReplicationControllerCondition(a.(*core.ReplicationControllerCondition), b.(*corev1.ReplicationControllerCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ReplicationControllerList)(nil), (*core.ReplicationControllerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicationControllerList_To_core_ReplicationControllerList(a.(*corev1.ReplicationControllerList), b.(*core.ReplicationControllerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ReplicationControllerList)(nil), (*corev1.ReplicationControllerList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ReplicationControllerList_To_v1_ReplicationControllerList(a.(*core.ReplicationControllerList), b.(*corev1.ReplicationControllerList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ReplicationControllerStatus)(nil), (*core.ReplicationControllerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicationControllerStatus_To_core_ReplicationControllerStatus(a.(*corev1.ReplicationControllerStatus), b.(*core.ReplicationControllerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ReplicationControllerStatus)(nil), (*corev1.ReplicationControllerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(a.(*core.ReplicationControllerStatus), b.(*corev1.ReplicationControllerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceClaim)(nil), (*core.ResourceClaim)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceClaim_To_core_ResourceClaim(a.(*corev1.ResourceClaim), b.(*core.ResourceClaim), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceClaim)(nil), (*corev1.ResourceClaim)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceClaim_To_v1_ResourceClaim(a.(*core.ResourceClaim), b.(*corev1.ResourceClaim), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceFieldSelector)(nil), (*core.ResourceFieldSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceFieldSelector_To_core_ResourceFieldSelector(a.(*corev1.ResourceFieldSelector), b.(*core.ResourceFieldSelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceFieldSelector)(nil), (*corev1.ResourceFieldSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceFieldSelector_To_v1_ResourceFieldSelector(a.(*core.ResourceFieldSelector), b.(*corev1.ResourceFieldSelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceHealth)(nil), (*core.ResourceHealth)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceHealth_To_core_ResourceHealth(a.(*corev1.ResourceHealth), b.(*core.ResourceHealth), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceHealth)(nil), (*corev1.ResourceHealth)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceHealth_To_v1_ResourceHealth(a.(*core.ResourceHealth), b.(*corev1.ResourceHealth), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceQuota)(nil), (*core.ResourceQuota)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceQuota_To_core_ResourceQuota(a.(*corev1.ResourceQuota), b.(*core.ResourceQuota), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceQuota)(nil), (*corev1.ResourceQuota)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceQuota_To_v1_ResourceQuota(a.(*core.ResourceQuota), b.(*corev1.ResourceQuota), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceQuotaList)(nil), (*core.ResourceQuotaList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceQuotaList_To_core_ResourceQuotaList(a.(*corev1.ResourceQuotaList), b.(*core.ResourceQuotaList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceQuotaList)(nil), (*corev1.ResourceQuotaList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceQuotaList_To_v1_ResourceQuotaList(a.(*core.ResourceQuotaList), b.(*corev1.ResourceQuotaList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceQuotaSpec)(nil), (*core.ResourceQuotaSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceQuotaSpec_To_core_ResourceQuotaSpec(a.(*corev1.ResourceQuotaSpec), b.(*core.ResourceQuotaSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceQuotaSpec)(nil), (*corev1.ResourceQuotaSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(a.(*core.ResourceQuotaSpec), b.(*corev1.ResourceQuotaSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceQuotaStatus)(nil), (*core.ResourceQuotaStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceQuotaStatus_To_core_ResourceQuotaStatus(a.(*corev1.ResourceQuotaStatus), b.(*core.ResourceQuotaStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceQuotaStatus)(nil), (*corev1.ResourceQuotaStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(a.(*core.ResourceQuotaStatus), b.(*corev1.ResourceQuotaStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceRequirements)(nil), (*core.ResourceRequirements)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceRequirements_To_core_ResourceRequirements(a.(*corev1.ResourceRequirements), b.(*core.ResourceRequirements), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceRequirements)(nil), (*corev1.ResourceRequirements)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceRequirements_To_v1_ResourceRequirements(a.(*core.ResourceRequirements), b.(*corev1.ResourceRequirements), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ResourceStatus)(nil), (*core.ResourceStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceStatus_To_core_ResourceStatus(a.(*corev1.ResourceStatus), b.(*core.ResourceStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ResourceStatus)(nil), (*corev1.ResourceStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ResourceStatus_To_v1_ResourceStatus(a.(*core.ResourceStatus), b.(*corev1.ResourceStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SELinuxOptions)(nil), (*core.SELinuxOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SELinuxOptions_To_core_SELinuxOptions(a.(*corev1.SELinuxOptions), b.(*core.SELinuxOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SELinuxOptions)(nil), (*corev1.SELinuxOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SELinuxOptions_To_v1_SELinuxOptions(a.(*core.SELinuxOptions), b.(*corev1.SELinuxOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ScaleIOPersistentVolumeSource)(nil), (*core.ScaleIOPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ScaleIOPersistentVolumeSource_To_core_ScaleIOPersistentVolumeSource(a.(*corev1.ScaleIOPersistentVolumeSource), b.(*core.ScaleIOPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ScaleIOPersistentVolumeSource)(nil), (*corev1.ScaleIOPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ScaleIOPersistentVolumeSource_To_v1_ScaleIOPersistentVolumeSource(a.(*core.ScaleIOPersistentVolumeSource), b.(*corev1.ScaleIOPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ScaleIOVolumeSource)(nil), (*core.ScaleIOVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ScaleIOVolumeSource_To_core_ScaleIOVolumeSource(a.(*corev1.ScaleIOVolumeSource), b.(*core.ScaleIOVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ScaleIOVolumeSource)(nil), (*corev1.ScaleIOVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ScaleIOVolumeSource_To_v1_ScaleIOVolumeSource(a.(*core.ScaleIOVolumeSource), b.(*corev1.ScaleIOVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ScopeSelector)(nil), (*core.ScopeSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ScopeSelector_To_core_ScopeSelector(a.(*corev1.ScopeSelector), b.(*core.ScopeSelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ScopeSelector)(nil), (*corev1.ScopeSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ScopeSelector_To_v1_ScopeSelector(a.(*core.ScopeSelector), b.(*corev1.ScopeSelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ScopedResourceSelectorRequirement)(nil), (*core.ScopedResourceSelectorRequirement)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ScopedResourceSelectorRequirement_To_core_ScopedResourceSelectorRequirement(a.(*corev1.ScopedResourceSelectorRequirement), b.(*core.ScopedResourceSelectorRequirement), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ScopedResourceSelectorRequirement)(nil), (*corev1.ScopedResourceSelectorRequirement)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ScopedResourceSelectorRequirement_To_v1_ScopedResourceSelectorRequirement(a.(*core.ScopedResourceSelectorRequirement), b.(*corev1.ScopedResourceSelectorRequirement), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SeccompProfile)(nil), (*core.SeccompProfile)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SeccompProfile_To_core_SeccompProfile(a.(*corev1.SeccompProfile), b.(*core.SeccompProfile), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SeccompProfile)(nil), (*corev1.SeccompProfile)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SeccompProfile_To_v1_SeccompProfile(a.(*core.SeccompProfile), b.(*corev1.SeccompProfile), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Secret)(nil), (*corev1.Secret)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Secret_To_v1_Secret(a.(*core.Secret), b.(*corev1.Secret), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SecretEnvSource)(nil), (*core.SecretEnvSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SecretEnvSource_To_core_SecretEnvSource(a.(*corev1.SecretEnvSource), b.(*core.SecretEnvSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SecretEnvSource)(nil), (*corev1.SecretEnvSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SecretEnvSource_To_v1_SecretEnvSource(a.(*core.SecretEnvSource), b.(*corev1.SecretEnvSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SecretKeySelector)(nil), (*core.SecretKeySelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SecretKeySelector_To_core_SecretKeySelector(a.(*corev1.SecretKeySelector), b.(*core.SecretKeySelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SecretKeySelector)(nil), (*corev1.SecretKeySelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SecretKeySelector_To_v1_SecretKeySelector(a.(*core.SecretKeySelector), b.(*corev1.SecretKeySelector), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SecretList)(nil), (*core.SecretList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SecretList_To_core_SecretList(a.(*corev1.SecretList), b.(*core.SecretList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SecretList)(nil), (*corev1.SecretList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SecretList_To_v1_SecretList(a.(*core.SecretList), b.(*corev1.SecretList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SecretProjection)(nil), (*core.SecretProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SecretProjection_To_core_SecretProjection(a.(*corev1.SecretProjection), b.(*core.SecretProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SecretProjection)(nil), (*corev1.SecretProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SecretProjection_To_v1_SecretProjection(a.(*core.SecretProjection), b.(*corev1.SecretProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SecretReference)(nil), (*core.SecretReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SecretReference_To_core_SecretReference(a.(*corev1.SecretReference), b.(*core.SecretReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SecretReference)(nil), (*corev1.SecretReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SecretReference_To_v1_SecretReference(a.(*core.SecretReference), b.(*corev1.SecretReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SecretVolumeSource)(nil), (*core.SecretVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SecretVolumeSource_To_core_SecretVolumeSource(a.(*corev1.SecretVolumeSource), b.(*core.SecretVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SecretVolumeSource)(nil), (*corev1.SecretVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SecretVolumeSource_To_v1_SecretVolumeSource(a.(*core.SecretVolumeSource), b.(*corev1.SecretVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SecurityContext)(nil), (*core.SecurityContext)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SecurityContext_To_core_SecurityContext(a.(*corev1.SecurityContext), b.(*core.SecurityContext), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SecurityContext)(nil), (*corev1.SecurityContext)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SecurityContext_To_v1_SecurityContext(a.(*core.SecurityContext), b.(*corev1.SecurityContext), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SerializedReference)(nil), (*core.SerializedReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SerializedReference_To_core_SerializedReference(a.(*corev1.SerializedReference), b.(*core.SerializedReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SerializedReference)(nil), (*corev1.SerializedReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SerializedReference_To_v1_SerializedReference(a.(*core.SerializedReference), b.(*corev1.SerializedReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Service)(nil), (*core.Service)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Service_To_core_Service(a.(*corev1.Service), b.(*core.Service), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Service)(nil), (*corev1.Service)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Service_To_v1_Service(a.(*core.Service), b.(*corev1.Service), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ServiceAccount)(nil), (*core.ServiceAccount)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceAccount_To_core_ServiceAccount(a.(*corev1.ServiceAccount), b.(*core.ServiceAccount), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ServiceAccount)(nil), (*corev1.ServiceAccount)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ServiceAccount_To_v1_ServiceAccount(a.(*core.ServiceAccount), b.(*corev1.ServiceAccount), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ServiceAccountList)(nil), (*core.ServiceAccountList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceAccountList_To_core_ServiceAccountList(a.(*corev1.ServiceAccountList), b.(*core.ServiceAccountList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ServiceAccountList)(nil), (*corev1.ServiceAccountList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ServiceAccountList_To_v1_ServiceAccountList(a.(*core.ServiceAccountList), b.(*corev1.ServiceAccountList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ServiceAccountTokenProjection)(nil), (*core.ServiceAccountTokenProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceAccountTokenProjection_To_core_ServiceAccountTokenProjection(a.(*corev1.ServiceAccountTokenProjection), b.(*core.ServiceAccountTokenProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ServiceAccountTokenProjection)(nil), (*corev1.ServiceAccountTokenProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ServiceAccountTokenProjection_To_v1_ServiceAccountTokenProjection(a.(*core.ServiceAccountTokenProjection), b.(*corev1.ServiceAccountTokenProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ServiceList)(nil), (*core.ServiceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceList_To_core_ServiceList(a.(*corev1.ServiceList), b.(*core.ServiceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ServiceList)(nil), (*corev1.ServiceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ServiceList_To_v1_ServiceList(a.(*core.ServiceList), b.(*corev1.ServiceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ServicePort)(nil), (*core.ServicePort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServicePort_To_core_ServicePort(a.(*corev1.ServicePort), b.(*core.ServicePort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ServicePort)(nil), (*corev1.ServicePort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ServicePort_To_v1_ServicePort(a.(*core.ServicePort), b.(*corev1.ServicePort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ServiceProxyOptions)(nil), (*core.ServiceProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceProxyOptions_To_core_ServiceProxyOptions(a.(*corev1.ServiceProxyOptions), b.(*core.ServiceProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ServiceProxyOptions)(nil), (*corev1.ServiceProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ServiceProxyOptions_To_v1_ServiceProxyOptions(a.(*core.ServiceProxyOptions), b.(*corev1.ServiceProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ServiceSpec)(nil), (*core.ServiceSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceSpec_To_core_ServiceSpec(a.(*corev1.ServiceSpec), b.(*core.ServiceSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ServiceSpec)(nil), (*corev1.ServiceSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ServiceSpec_To_v1_ServiceSpec(a.(*core.ServiceSpec), b.(*corev1.ServiceSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.ServiceStatus)(nil), (*core.ServiceStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceStatus_To_core_ServiceStatus(a.(*corev1.ServiceStatus), b.(*core.ServiceStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.ServiceStatus)(nil), (*corev1.ServiceStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ServiceStatus_To_v1_ServiceStatus(a.(*core.ServiceStatus), b.(*corev1.ServiceStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SessionAffinityConfig)(nil), (*core.SessionAffinityConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SessionAffinityConfig_To_core_SessionAffinityConfig(a.(*corev1.SessionAffinityConfig), b.(*core.SessionAffinityConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SessionAffinityConfig)(nil), (*corev1.SessionAffinityConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SessionAffinityConfig_To_v1_SessionAffinityConfig(a.(*core.SessionAffinityConfig), b.(*corev1.SessionAffinityConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.SleepAction)(nil), (*core.SleepAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_SleepAction_To_core_SleepAction(a.(*corev1.SleepAction), b.(*core.SleepAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.SleepAction)(nil), (*corev1.SleepAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_SleepAction_To_v1_SleepAction(a.(*core.SleepAction), b.(*corev1.SleepAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.StorageOSPersistentVolumeSource)(nil), (*core.StorageOSPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StorageOSPersistentVolumeSource_To_core_StorageOSPersistentVolumeSource(a.(*corev1.StorageOSPersistentVolumeSource), b.(*core.StorageOSPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.StorageOSPersistentVolumeSource)(nil), (*corev1.StorageOSPersistentVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_StorageOSPersistentVolumeSource_To_v1_StorageOSPersistentVolumeSource(a.(*core.StorageOSPersistentVolumeSource), b.(*corev1.StorageOSPersistentVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.StorageOSVolumeSource)(nil), (*core.StorageOSVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_StorageOSVolumeSource_To_core_StorageOSVolumeSource(a.(*corev1.StorageOSVolumeSource), b.(*core.StorageOSVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.StorageOSVolumeSource)(nil), (*corev1.StorageOSVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_StorageOSVolumeSource_To_v1_StorageOSVolumeSource(a.(*core.StorageOSVolumeSource), b.(*corev1.StorageOSVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Sysctl)(nil), (*core.Sysctl)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Sysctl_To_core_Sysctl(a.(*corev1.Sysctl), b.(*core.Sysctl), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Sysctl)(nil), (*corev1.Sysctl)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Sysctl_To_v1_Sysctl(a.(*core.Sysctl), b.(*corev1.Sysctl), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.TCPSocketAction)(nil), (*core.TCPSocketAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TCPSocketAction_To_core_TCPSocketAction(a.(*corev1.TCPSocketAction), b.(*core.TCPSocketAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.TCPSocketAction)(nil), (*corev1.TCPSocketAction)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_TCPSocketAction_To_v1_TCPSocketAction(a.(*core.TCPSocketAction), b.(*corev1.TCPSocketAction), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Taint)(nil), (*core.Taint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Taint_To_core_Taint(a.(*corev1.Taint), b.(*core.Taint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Taint)(nil), (*corev1.Taint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Taint_To_v1_Taint(a.(*core.Taint), b.(*corev1.Taint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Toleration)(nil), (*core.Toleration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Toleration_To_core_Toleration(a.(*corev1.Toleration), b.(*core.Toleration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Toleration)(nil), (*corev1.Toleration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Toleration_To_v1_Toleration(a.(*core.Toleration), b.(*corev1.Toleration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.TopologySelectorLabelRequirement)(nil), (*core.TopologySelectorLabelRequirement)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TopologySelectorLabelRequirement_To_core_TopologySelectorLabelRequirement(a.(*corev1.TopologySelectorLabelRequirement), b.(*core.TopologySelectorLabelRequirement), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.TopologySelectorLabelRequirement)(nil), (*corev1.TopologySelectorLabelRequirement)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_TopologySelectorLabelRequirement_To_v1_TopologySelectorLabelRequirement(a.(*core.TopologySelectorLabelRequirement), b.(*corev1.TopologySelectorLabelRequirement), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.TopologySelectorTerm)(nil), (*core.TopologySelectorTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TopologySelectorTerm_To_core_TopologySelectorTerm(a.(*corev1.TopologySelectorTerm), b.(*core.TopologySelectorTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.TopologySelectorTerm)(nil), (*corev1.TopologySelectorTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_TopologySelectorTerm_To_v1_TopologySelectorTerm(a.(*core.TopologySelectorTerm), b.(*corev1.TopologySelectorTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.TopologySpreadConstraint)(nil), (*core.TopologySpreadConstraint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TopologySpreadConstraint_To_core_TopologySpreadConstraint(a.(*corev1.TopologySpreadConstraint), b.(*core.TopologySpreadConstraint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.TopologySpreadConstraint)(nil), (*corev1.TopologySpreadConstraint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_TopologySpreadConstraint_To_v1_TopologySpreadConstraint(a.(*core.TopologySpreadConstraint), b.(*corev1.TopologySpreadConstraint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.TypedLocalObjectReference)(nil), (*core.TypedLocalObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TypedLocalObjectReference_To_core_TypedLocalObjectReference(a.(*corev1.TypedLocalObjectReference), b.(*core.TypedLocalObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.TypedLocalObjectReference)(nil), (*corev1.TypedLocalObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_TypedLocalObjectReference_To_v1_TypedLocalObjectReference(a.(*core.TypedLocalObjectReference), b.(*corev1.TypedLocalObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.TypedObjectReference)(nil), (*core.TypedObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_TypedObjectReference_To_core_TypedObjectReference(a.(*corev1.TypedObjectReference), b.(*core.TypedObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.TypedObjectReference)(nil), (*corev1.TypedObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_TypedObjectReference_To_v1_TypedObjectReference(a.(*core.TypedObjectReference), b.(*corev1.TypedObjectReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.Volume)(nil), (*core.Volume)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Volume_To_core_Volume(a.(*corev1.Volume), b.(*core.Volume), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.Volume)(nil), (*corev1.Volume)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Volume_To_v1_Volume(a.(*core.Volume), b.(*corev1.Volume), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.VolumeDevice)(nil), (*core.VolumeDevice)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_VolumeDevice_To_core_VolumeDevice(a.(*corev1.VolumeDevice), b.(*core.VolumeDevice), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.VolumeDevice)(nil), (*corev1.VolumeDevice)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_VolumeDevice_To_v1_VolumeDevice(a.(*core.VolumeDevice), b.(*corev1.VolumeDevice), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.VolumeMount)(nil), (*core.VolumeMount)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_VolumeMount_To_core_VolumeMount(a.(*corev1.VolumeMount), b.(*core.VolumeMount), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.VolumeMount)(nil), (*corev1.VolumeMount)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_VolumeMount_To_v1_VolumeMount(a.(*core.VolumeMount), b.(*corev1.VolumeMount), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.VolumeMountStatus)(nil), (*core.VolumeMountStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_VolumeMountStatus_To_core_VolumeMountStatus(a.(*corev1.VolumeMountStatus), b.(*core.VolumeMountStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.VolumeMountStatus)(nil), (*corev1.VolumeMountStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_VolumeMountStatus_To_v1_VolumeMountStatus(a.(*core.VolumeMountStatus), b.(*corev1.VolumeMountStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.VolumeNodeAffinity)(nil), (*core.VolumeNodeAffinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_VolumeNodeAffinity_To_core_VolumeNodeAffinity(a.(*corev1.VolumeNodeAffinity), b.(*core.VolumeNodeAffinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.VolumeNodeAffinity)(nil), (*corev1.VolumeNodeAffinity)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_VolumeNodeAffinity_To_v1_VolumeNodeAffinity(a.(*core.VolumeNodeAffinity), b.(*corev1.VolumeNodeAffinity), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.VolumeProjection)(nil), (*core.VolumeProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_VolumeProjection_To_core_VolumeProjection(a.(*corev1.VolumeProjection), b.(*core.VolumeProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.VolumeProjection)(nil), (*corev1.VolumeProjection)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_VolumeProjection_To_v1_VolumeProjection(a.(*core.VolumeProjection), b.(*corev1.VolumeProjection), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.VolumeResourceRequirements)(nil), (*core.VolumeResourceRequirements)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_VolumeResourceRequirements_To_core_VolumeResourceRequirements(a.(*corev1.VolumeResourceRequirements), b.(*core.VolumeResourceRequirements), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.VolumeResourceRequirements)(nil), (*corev1.VolumeResourceRequirements)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_VolumeResourceRequirements_To_v1_VolumeResourceRequirements(a.(*core.VolumeResourceRequirements), b.(*corev1.VolumeResourceRequirements), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.VolumeSource)(nil), (*core.VolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_VolumeSource_To_core_VolumeSource(a.(*corev1.VolumeSource), b.(*core.VolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.VolumeSource)(nil), (*corev1.VolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_VolumeSource_To_v1_VolumeSource(a.(*core.VolumeSource), b.(*corev1.VolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.VsphereVirtualDiskVolumeSource)(nil), (*core.VsphereVirtualDiskVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_VsphereVirtualDiskVolumeSource_To_core_VsphereVirtualDiskVolumeSource(a.(*corev1.VsphereVirtualDiskVolumeSource), b.(*core.VsphereVirtualDiskVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.VsphereVirtualDiskVolumeSource)(nil), (*corev1.VsphereVirtualDiskVolumeSource)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(a.(*core.VsphereVirtualDiskVolumeSource), b.(*corev1.VsphereVirtualDiskVolumeSource), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.WeightedPodAffinityTerm)(nil), (*core.WeightedPodAffinityTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_WeightedPodAffinityTerm_To_core_WeightedPodAffinityTerm(a.(*corev1.WeightedPodAffinityTerm), b.(*core.WeightedPodAffinityTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.WeightedPodAffinityTerm)(nil), (*corev1.WeightedPodAffinityTerm)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(a.(*core.WeightedPodAffinityTerm), b.(*corev1.WeightedPodAffinityTerm), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*corev1.WindowsSecurityContextOptions)(nil), (*core.WindowsSecurityContextOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_WindowsSecurityContextOptions_To_core_WindowsSecurityContextOptions(a.(*corev1.WindowsSecurityContextOptions), b.(*core.WindowsSecurityContextOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.WindowsSecurityContextOptions)(nil), (*corev1.WindowsSecurityContextOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_WindowsSecurityContextOptions_To_v1_WindowsSecurityContextOptions(a.(*core.WindowsSecurityContextOptions), b.(*corev1.WindowsSecurityContextOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*url.Values)(nil), (*corev1.NodeProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_url_Values_To_v1_NodeProxyOptions(a.(*url.Values), b.(*corev1.NodeProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*url.Values)(nil), (*corev1.PodAttachOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_url_Values_To_v1_PodAttachOptions(a.(*url.Values), b.(*corev1.PodAttachOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*url.Values)(nil), (*corev1.PodExecOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_url_Values_To_v1_PodExecOptions(a.(*url.Values), b.(*corev1.PodExecOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*url.Values)(nil), (*corev1.PodLogOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_url_Values_To_v1_PodLogOptions(a.(*url.Values), b.(*corev1.PodLogOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*url.Values)(nil), (*corev1.PodPortForwardOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_url_Values_To_v1_PodPortForwardOptions(a.(*url.Values), b.(*corev1.PodPortForwardOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*url.Values)(nil), (*corev1.PodProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_url_Values_To_v1_PodProxyOptions(a.(*url.Values), b.(*corev1.PodProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*url.Values)(nil), (*corev1.ServiceProxyOptions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_url_Values_To_v1_ServiceProxyOptions(a.(*url.Values), b.(*corev1.ServiceProxyOptions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*[]string)(nil), (**string)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_Slice_string_To_Pointer_string(a.(*[]string), b.(**string), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.ReplicaSetSpec)(nil), (*corev1.ReplicationControllerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetSpec_To_v1_ReplicationControllerSpec(a.(*apps.ReplicaSetSpec), b.(*corev1.ReplicationControllerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.ReplicaSetStatus)(nil), (*corev1.ReplicationControllerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetStatus_To_v1_ReplicationControllerStatus(a.(*apps.ReplicaSetStatus), b.(*corev1.ReplicationControllerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*apps.ReplicaSet)(nil), (*corev1.ReplicationController)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSet_To_v1_ReplicationController(a.(*apps.ReplicaSet), b.(*corev1.ReplicationController), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.NodeSpec)(nil), (*corev1.NodeSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_NodeSpec_To_v1_NodeSpec(a.(*core.NodeSpec), b.(*corev1.NodeSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.PersistentVolumeSpec)(nil), (*corev1.PersistentVolumeSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(a.(*core.PersistentVolumeSpec), b.(*corev1.PersistentVolumeSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.PodSpec)(nil), (*corev1.PodSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodSpec_To_v1_PodSpec(a.(*core.PodSpec), b.(*corev1.PodSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.PodStatus)(nil), (*corev1.PodStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodStatus_To_v1_PodStatus(a.(*core.PodStatus), b.(*corev1.PodStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.PodTemplateSpec)(nil), (*corev1.PodTemplateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(a.(*core.PodTemplateSpec), b.(*corev1.PodTemplateSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.Pod)(nil), (*corev1.Pod)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Pod_To_v1_Pod(a.(*core.Pod), b.(*corev1.Pod), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.ReplicationControllerSpec)(nil), (*corev1.ReplicationControllerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(a.(*core.ReplicationControllerSpec), b.(*corev1.ReplicationControllerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.NodeSpec)(nil), (*core.NodeSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NodeSpec_To_core_NodeSpec(a.(*corev1.NodeSpec), b.(*core.NodeSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.PersistentVolumeSpec)(nil), (*core.PersistentVolumeSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PersistentVolumeSpec_To_core_PersistentVolumeSpec(a.(*corev1.PersistentVolumeSpec), b.(*core.PersistentVolumeSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.PodSpec)(nil), (*core.PodSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodSpec_To_core_PodSpec(a.(*corev1.PodSpec), b.(*core.PodSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.PodStatus)(nil), (*core.PodStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodStatus_To_core_PodStatus(a.(*corev1.PodStatus), b.(*core.PodStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.PodTemplateSpec)(nil), (*core.PodTemplateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(a.(*corev1.PodTemplateSpec), b.(*core.PodTemplateSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.Pod)(nil), (*core.Pod)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Pod_To_core_Pod(a.(*corev1.Pod), b.(*core.Pod), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.ReplicationControllerSpec)(nil), (*apps.ReplicaSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicationControllerSpec_To_apps_ReplicaSetSpec(a.(*corev1.ReplicationControllerSpec), b.(*apps.ReplicaSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.ReplicationControllerSpec)(nil), (*core.ReplicationControllerSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicationControllerSpec_To_core_ReplicationControllerSpec(a.(*corev1.ReplicationControllerSpec), b.(*core.ReplicationControllerSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.ReplicationControllerStatus)(nil), (*apps.ReplicaSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicationControllerStatus_To_apps_ReplicaSetStatus(a.(*corev1.ReplicationControllerStatus), b.(*apps.ReplicaSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.ReplicationController)(nil), (*apps.ReplicaSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ReplicationController_To_apps_ReplicaSet(a.(*corev1.ReplicationController), b.(*apps.ReplicaSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.ResourceList)(nil), (*core.ResourceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourceList_To_core_ResourceList(a.(*corev1.ResourceList), b.(*core.ResourceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*corev1.Secret)(nil), (*core.Secret)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Secret_To_core_Secret(a.(*corev1.Secret), b.(*core.Secret), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_core_AWSElasticBlockStoreVolumeSource(in *corev1.AWSElasticBlockStoreVolumeSource, out *core.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
        out.VolumeID = in.VolumeID
        out.FSType = in.FSType
        out.Partition = in.Partition
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_AWSElasticBlockStoreVolumeSource_To_core_AWSElasticBlockStoreVolumeSource is an autogenerated conversion function.
func Convert_v1_AWSElasticBlockStoreVolumeSource_To_core_AWSElasticBlockStoreVolumeSource(in *corev1.AWSElasticBlockStoreVolumeSource, out *core.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_AWSElasticBlockStoreVolumeSource_To_core_AWSElasticBlockStoreVolumeSource(in, out, s)
}

func autoConvert_core_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in *core.AWSElasticBlockStoreVolumeSource, out *corev1.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
        out.VolumeID = in.VolumeID
        out.FSType = in.FSType
        out.Partition = in.Partition
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource is an autogenerated conversion function.
func Convert_core_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in *core.AWSElasticBlockStoreVolumeSource, out *corev1.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error {
        return autoConvert_core_AWSElasticBlockStoreVolumeSource_To_v1_AWSElasticBlockStoreVolumeSource(in, out, s)
}

func autoConvert_v1_Affinity_To_core_Affinity(in *corev1.Affinity, out *core.Affinity, s conversion.Scope) error {
        out.NodeAffinity = (*core.NodeAffinity)(unsafe.Pointer(in.NodeAffinity))
        out.PodAffinity = (*core.PodAffinity)(unsafe.Pointer(in.PodAffinity))
        out.PodAntiAffinity = (*core.PodAntiAffinity)(unsafe.Pointer(in.PodAntiAffinity))
        return nil
}

// Convert_v1_Affinity_To_core_Affinity is an autogenerated conversion function.
func Convert_v1_Affinity_To_core_Affinity(in *corev1.Affinity, out *core.Affinity, s conversion.Scope) error {
        return autoConvert_v1_Affinity_To_core_Affinity(in, out, s)
}

func autoConvert_core_Affinity_To_v1_Affinity(in *core.Affinity, out *corev1.Affinity, s conversion.Scope) error {
        out.NodeAffinity = (*corev1.NodeAffinity)(unsafe.Pointer(in.NodeAffinity))
        out.PodAffinity = (*corev1.PodAffinity)(unsafe.Pointer(in.PodAffinity))
        out.PodAntiAffinity = (*corev1.PodAntiAffinity)(unsafe.Pointer(in.PodAntiAffinity))
        return nil
}

// Convert_core_Affinity_To_v1_Affinity is an autogenerated conversion function.
func Convert_core_Affinity_To_v1_Affinity(in *core.Affinity, out *corev1.Affinity, s conversion.Scope) error {
        return autoConvert_core_Affinity_To_v1_Affinity(in, out, s)
}

func autoConvert_v1_AppArmorProfile_To_core_AppArmorProfile(in *corev1.AppArmorProfile, out *core.AppArmorProfile, s conversion.Scope) error {
        out.Type = core.AppArmorProfileType(in.Type)
        out.LocalhostProfile = (*string)(unsafe.Pointer(in.LocalhostProfile))
        return nil
}

// Convert_v1_AppArmorProfile_To_core_AppArmorProfile is an autogenerated conversion function.
func Convert_v1_AppArmorProfile_To_core_AppArmorProfile(in *corev1.AppArmorProfile, out *core.AppArmorProfile, s conversion.Scope) error {
        return autoConvert_v1_AppArmorProfile_To_core_AppArmorProfile(in, out, s)
}

func autoConvert_core_AppArmorProfile_To_v1_AppArmorProfile(in *core.AppArmorProfile, out *corev1.AppArmorProfile, s conversion.Scope) error {
        out.Type = corev1.AppArmorProfileType(in.Type)
        out.LocalhostProfile = (*string)(unsafe.Pointer(in.LocalhostProfile))
        return nil
}

// Convert_core_AppArmorProfile_To_v1_AppArmorProfile is an autogenerated conversion function.
func Convert_core_AppArmorProfile_To_v1_AppArmorProfile(in *core.AppArmorProfile, out *corev1.AppArmorProfile, s conversion.Scope) error {
        return autoConvert_core_AppArmorProfile_To_v1_AppArmorProfile(in, out, s)
}

func autoConvert_v1_AttachedVolume_To_core_AttachedVolume(in *corev1.AttachedVolume, out *core.AttachedVolume, s conversion.Scope) error {
        out.Name = core.UniqueVolumeName(in.Name)
        out.DevicePath = in.DevicePath
        return nil
}

// Convert_v1_AttachedVolume_To_core_AttachedVolume is an autogenerated conversion function.
func Convert_v1_AttachedVolume_To_core_AttachedVolume(in *corev1.AttachedVolume, out *core.AttachedVolume, s conversion.Scope) error {
        return autoConvert_v1_AttachedVolume_To_core_AttachedVolume(in, out, s)
}

func autoConvert_core_AttachedVolume_To_v1_AttachedVolume(in *core.AttachedVolume, out *corev1.AttachedVolume, s conversion.Scope) error {
        out.Name = corev1.UniqueVolumeName(in.Name)
        out.DevicePath = in.DevicePath
        return nil
}

// Convert_core_AttachedVolume_To_v1_AttachedVolume is an autogenerated conversion function.
func Convert_core_AttachedVolume_To_v1_AttachedVolume(in *core.AttachedVolume, out *corev1.AttachedVolume, s conversion.Scope) error {
        return autoConvert_core_AttachedVolume_To_v1_AttachedVolume(in, out, s)
}

func autoConvert_v1_AvoidPods_To_core_AvoidPods(in *corev1.AvoidPods, out *core.AvoidPods, s conversion.Scope) error {
        out.PreferAvoidPods = *(*[]core.PreferAvoidPodsEntry)(unsafe.Pointer(&in.PreferAvoidPods))
        return nil
}

// Convert_v1_AvoidPods_To_core_AvoidPods is an autogenerated conversion function.
func Convert_v1_AvoidPods_To_core_AvoidPods(in *corev1.AvoidPods, out *core.AvoidPods, s conversion.Scope) error {
        return autoConvert_v1_AvoidPods_To_core_AvoidPods(in, out, s)
}

func autoConvert_core_AvoidPods_To_v1_AvoidPods(in *core.AvoidPods, out *corev1.AvoidPods, s conversion.Scope) error {
        out.PreferAvoidPods = *(*[]corev1.PreferAvoidPodsEntry)(unsafe.Pointer(&in.PreferAvoidPods))
        return nil
}

// Convert_core_AvoidPods_To_v1_AvoidPods is an autogenerated conversion function.
func Convert_core_AvoidPods_To_v1_AvoidPods(in *core.AvoidPods, out *corev1.AvoidPods, s conversion.Scope) error {
        return autoConvert_core_AvoidPods_To_v1_AvoidPods(in, out, s)
}

func autoConvert_v1_AzureDiskVolumeSource_To_core_AzureDiskVolumeSource(in *corev1.AzureDiskVolumeSource, out *core.AzureDiskVolumeSource, s conversion.Scope) error {
        out.DiskName = in.DiskName
        out.DataDiskURI = in.DataDiskURI
        out.CachingMode = (*core.AzureDataDiskCachingMode)(unsafe.Pointer(in.CachingMode))
        out.FSType = (*string)(unsafe.Pointer(in.FSType))
        out.ReadOnly = (*bool)(unsafe.Pointer(in.ReadOnly))
        out.Kind = (*core.AzureDataDiskKind)(unsafe.Pointer(in.Kind))
        return nil
}

// Convert_v1_AzureDiskVolumeSource_To_core_AzureDiskVolumeSource is an autogenerated conversion function.
func Convert_v1_AzureDiskVolumeSource_To_core_AzureDiskVolumeSource(in *corev1.AzureDiskVolumeSource, out *core.AzureDiskVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_AzureDiskVolumeSource_To_core_AzureDiskVolumeSource(in, out, s)
}

func autoConvert_core_AzureDiskVolumeSource_To_v1_AzureDiskVolumeSource(in *core.AzureDiskVolumeSource, out *corev1.AzureDiskVolumeSource, s conversion.Scope) error {
        out.DiskName = in.DiskName
        out.DataDiskURI = in.DataDiskURI
        out.CachingMode = (*corev1.AzureDataDiskCachingMode)(unsafe.Pointer(in.CachingMode))
        out.FSType = (*string)(unsafe.Pointer(in.FSType))
        out.ReadOnly = (*bool)(unsafe.Pointer(in.ReadOnly))
        out.Kind = (*corev1.AzureDataDiskKind)(unsafe.Pointer(in.Kind))
        return nil
}

// Convert_core_AzureDiskVolumeSource_To_v1_AzureDiskVolumeSource is an autogenerated conversion function.
func Convert_core_AzureDiskVolumeSource_To_v1_AzureDiskVolumeSource(in *core.AzureDiskVolumeSource, out *corev1.AzureDiskVolumeSource, s conversion.Scope) error {
        return autoConvert_core_AzureDiskVolumeSource_To_v1_AzureDiskVolumeSource(in, out, s)
}

func autoConvert_v1_AzureFilePersistentVolumeSource_To_core_AzureFilePersistentVolumeSource(in *corev1.AzureFilePersistentVolumeSource, out *core.AzureFilePersistentVolumeSource, s conversion.Scope) error {
        out.SecretName = in.SecretName
        out.ShareName = in.ShareName
        out.ReadOnly = in.ReadOnly
        out.SecretNamespace = (*string)(unsafe.Pointer(in.SecretNamespace))
        return nil
}

// Convert_v1_AzureFilePersistentVolumeSource_To_core_AzureFilePersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_AzureFilePersistentVolumeSource_To_core_AzureFilePersistentVolumeSource(in *corev1.AzureFilePersistentVolumeSource, out *core.AzureFilePersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_AzureFilePersistentVolumeSource_To_core_AzureFilePersistentVolumeSource(in, out, s)
}

func autoConvert_core_AzureFilePersistentVolumeSource_To_v1_AzureFilePersistentVolumeSource(in *core.AzureFilePersistentVolumeSource, out *corev1.AzureFilePersistentVolumeSource, s conversion.Scope) error {
        out.SecretName = in.SecretName
        out.ShareName = in.ShareName
        out.ReadOnly = in.ReadOnly
        out.SecretNamespace = (*string)(unsafe.Pointer(in.SecretNamespace))
        return nil
}

// Convert_core_AzureFilePersistentVolumeSource_To_v1_AzureFilePersistentVolumeSource is an autogenerated conversion function.
func Convert_core_AzureFilePersistentVolumeSource_To_v1_AzureFilePersistentVolumeSource(in *core.AzureFilePersistentVolumeSource, out *corev1.AzureFilePersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_AzureFilePersistentVolumeSource_To_v1_AzureFilePersistentVolumeSource(in, out, s)
}

func autoConvert_v1_AzureFileVolumeSource_To_core_AzureFileVolumeSource(in *corev1.AzureFileVolumeSource, out *core.AzureFileVolumeSource, s conversion.Scope) error {
        out.SecretName = in.SecretName
        out.ShareName = in.ShareName
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_AzureFileVolumeSource_To_core_AzureFileVolumeSource is an autogenerated conversion function.
func Convert_v1_AzureFileVolumeSource_To_core_AzureFileVolumeSource(in *corev1.AzureFileVolumeSource, out *core.AzureFileVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_AzureFileVolumeSource_To_core_AzureFileVolumeSource(in, out, s)
}

func autoConvert_core_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *core.AzureFileVolumeSource, out *corev1.AzureFileVolumeSource, s conversion.Scope) error {
        out.SecretName = in.SecretName
        out.ShareName = in.ShareName
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_AzureFileVolumeSource_To_v1_AzureFileVolumeSource is an autogenerated conversion function.
func Convert_core_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in *core.AzureFileVolumeSource, out *corev1.AzureFileVolumeSource, s conversion.Scope) error {
        return autoConvert_core_AzureFileVolumeSource_To_v1_AzureFileVolumeSource(in, out, s)
}

func autoConvert_v1_Binding_To_core_Binding(in *corev1.Binding, out *core.Binding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ObjectReference_To_core_ObjectReference(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_Binding_To_core_Binding is an autogenerated conversion function.
func Convert_v1_Binding_To_core_Binding(in *corev1.Binding, out *core.Binding, s conversion.Scope) error {
        return autoConvert_v1_Binding_To_core_Binding(in, out, s)
}

func autoConvert_core_Binding_To_v1_Binding(in *core.Binding, out *corev1.Binding, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_ObjectReference_To_v1_ObjectReference(&in.Target, &out.Target, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_Binding_To_v1_Binding is an autogenerated conversion function.
func Convert_core_Binding_To_v1_Binding(in *core.Binding, out *corev1.Binding, s conversion.Scope) error {
        return autoConvert_core_Binding_To_v1_Binding(in, out, s)
}

func autoConvert_v1_CSIPersistentVolumeSource_To_core_CSIPersistentVolumeSource(in *corev1.CSIPersistentVolumeSource, out *core.CSIPersistentVolumeSource, s conversion.Scope) error {
        out.Driver = in.Driver
        out.VolumeHandle = in.VolumeHandle
        out.ReadOnly = in.ReadOnly
        out.FSType = in.FSType
        out.VolumeAttributes = *(*map[string]string)(unsafe.Pointer(&in.VolumeAttributes))
        out.ControllerPublishSecretRef = (*core.SecretReference)(unsafe.Pointer(in.ControllerPublishSecretRef))
        out.NodeStageSecretRef = (*core.SecretReference)(unsafe.Pointer(in.NodeStageSecretRef))
        out.NodePublishSecretRef = (*core.SecretReference)(unsafe.Pointer(in.NodePublishSecretRef))
        out.ControllerExpandSecretRef = (*core.SecretReference)(unsafe.Pointer(in.ControllerExpandSecretRef))
        out.NodeExpandSecretRef = (*core.SecretReference)(unsafe.Pointer(in.NodeExpandSecretRef))
        return nil
}

// Convert_v1_CSIPersistentVolumeSource_To_core_CSIPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_CSIPersistentVolumeSource_To_core_CSIPersistentVolumeSource(in *corev1.CSIPersistentVolumeSource, out *core.CSIPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_CSIPersistentVolumeSource_To_core_CSIPersistentVolumeSource(in, out, s)
}

func autoConvert_core_CSIPersistentVolumeSource_To_v1_CSIPersistentVolumeSource(in *core.CSIPersistentVolumeSource, out *corev1.CSIPersistentVolumeSource, s conversion.Scope) error {
        out.Driver = in.Driver
        out.VolumeHandle = in.VolumeHandle
        out.ReadOnly = in.ReadOnly
        out.FSType = in.FSType
        out.VolumeAttributes = *(*map[string]string)(unsafe.Pointer(&in.VolumeAttributes))
        out.ControllerPublishSecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.ControllerPublishSecretRef))
        out.NodeStageSecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.NodeStageSecretRef))
        out.NodePublishSecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.NodePublishSecretRef))
        out.ControllerExpandSecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.ControllerExpandSecretRef))
        out.NodeExpandSecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.NodeExpandSecretRef))
        return nil
}

// Convert_core_CSIPersistentVolumeSource_To_v1_CSIPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_CSIPersistentVolumeSource_To_v1_CSIPersistentVolumeSource(in *core.CSIPersistentVolumeSource, out *corev1.CSIPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_CSIPersistentVolumeSource_To_v1_CSIPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_CSIVolumeSource_To_core_CSIVolumeSource(in *corev1.CSIVolumeSource, out *core.CSIVolumeSource, s conversion.Scope) error {
        out.Driver = in.Driver
        out.ReadOnly = (*bool)(unsafe.Pointer(in.ReadOnly))
        out.FSType = (*string)(unsafe.Pointer(in.FSType))
        out.VolumeAttributes = *(*map[string]string)(unsafe.Pointer(&in.VolumeAttributes))
        out.NodePublishSecretRef = (*core.LocalObjectReference)(unsafe.Pointer(in.NodePublishSecretRef))
        return nil
}

// Convert_v1_CSIVolumeSource_To_core_CSIVolumeSource is an autogenerated conversion function.
func Convert_v1_CSIVolumeSource_To_core_CSIVolumeSource(in *corev1.CSIVolumeSource, out *core.CSIVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_CSIVolumeSource_To_core_CSIVolumeSource(in, out, s)
}

func autoConvert_core_CSIVolumeSource_To_v1_CSIVolumeSource(in *core.CSIVolumeSource, out *corev1.CSIVolumeSource, s conversion.Scope) error {
        out.Driver = in.Driver
        out.ReadOnly = (*bool)(unsafe.Pointer(in.ReadOnly))
        out.FSType = (*string)(unsafe.Pointer(in.FSType))
        out.VolumeAttributes = *(*map[string]string)(unsafe.Pointer(&in.VolumeAttributes))
        out.NodePublishSecretRef = (*corev1.LocalObjectReference)(unsafe.Pointer(in.NodePublishSecretRef))
        return nil
}

// Convert_core_CSIVolumeSource_To_v1_CSIVolumeSource is an autogenerated conversion function.
func Convert_core_CSIVolumeSource_To_v1_CSIVolumeSource(in *core.CSIVolumeSource, out *corev1.CSIVolumeSource, s conversion.Scope) error {
        return autoConvert_core_CSIVolumeSource_To_v1_CSIVolumeSource(in, out, s)
}

func autoConvert_v1_Capabilities_To_core_Capabilities(in *corev1.Capabilities, out *core.Capabilities, s conversion.Scope) error {
        out.Add = *(*[]core.Capability)(unsafe.Pointer(&in.Add))
        out.Drop = *(*[]core.Capability)(unsafe.Pointer(&in.Drop))
        return nil
}

// Convert_v1_Capabilities_To_core_Capabilities is an autogenerated conversion function.
func Convert_v1_Capabilities_To_core_Capabilities(in *corev1.Capabilities, out *core.Capabilities, s conversion.Scope) error {
        return autoConvert_v1_Capabilities_To_core_Capabilities(in, out, s)
}

func autoConvert_core_Capabilities_To_v1_Capabilities(in *core.Capabilities, out *corev1.Capabilities, s conversion.Scope) error {
        out.Add = *(*[]corev1.Capability)(unsafe.Pointer(&in.Add))
        out.Drop = *(*[]corev1.Capability)(unsafe.Pointer(&in.Drop))
        return nil
}

// Convert_core_Capabilities_To_v1_Capabilities is an autogenerated conversion function.
func Convert_core_Capabilities_To_v1_Capabilities(in *core.Capabilities, out *corev1.Capabilities, s conversion.Scope) error {
        return autoConvert_core_Capabilities_To_v1_Capabilities(in, out, s)
}

func autoConvert_v1_CephFSPersistentVolumeSource_To_core_CephFSPersistentVolumeSource(in *corev1.CephFSPersistentVolumeSource, out *core.CephFSPersistentVolumeSource, s conversion.Scope) error {
        out.Monitors = *(*[]string)(unsafe.Pointer(&in.Monitors))
        out.Path = in.Path
        out.User = in.User
        out.SecretFile = in.SecretFile
        out.SecretRef = (*core.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_CephFSPersistentVolumeSource_To_core_CephFSPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_CephFSPersistentVolumeSource_To_core_CephFSPersistentVolumeSource(in *corev1.CephFSPersistentVolumeSource, out *core.CephFSPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_CephFSPersistentVolumeSource_To_core_CephFSPersistentVolumeSource(in, out, s)
}

func autoConvert_core_CephFSPersistentVolumeSource_To_v1_CephFSPersistentVolumeSource(in *core.CephFSPersistentVolumeSource, out *corev1.CephFSPersistentVolumeSource, s conversion.Scope) error {
        out.Monitors = *(*[]string)(unsafe.Pointer(&in.Monitors))
        out.Path = in.Path
        out.User = in.User
        out.SecretFile = in.SecretFile
        out.SecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_CephFSPersistentVolumeSource_To_v1_CephFSPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_CephFSPersistentVolumeSource_To_v1_CephFSPersistentVolumeSource(in *core.CephFSPersistentVolumeSource, out *corev1.CephFSPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_CephFSPersistentVolumeSource_To_v1_CephFSPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_CephFSVolumeSource_To_core_CephFSVolumeSource(in *corev1.CephFSVolumeSource, out *core.CephFSVolumeSource, s conversion.Scope) error {
        out.Monitors = *(*[]string)(unsafe.Pointer(&in.Monitors))
        out.Path = in.Path
        out.User = in.User
        out.SecretFile = in.SecretFile
        out.SecretRef = (*core.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_CephFSVolumeSource_To_core_CephFSVolumeSource is an autogenerated conversion function.
func Convert_v1_CephFSVolumeSource_To_core_CephFSVolumeSource(in *corev1.CephFSVolumeSource, out *core.CephFSVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_CephFSVolumeSource_To_core_CephFSVolumeSource(in, out, s)
}

func autoConvert_core_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *core.CephFSVolumeSource, out *corev1.CephFSVolumeSource, s conversion.Scope) error {
        out.Monitors = *(*[]string)(unsafe.Pointer(&in.Monitors))
        out.Path = in.Path
        out.User = in.User
        out.SecretFile = in.SecretFile
        out.SecretRef = (*corev1.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_CephFSVolumeSource_To_v1_CephFSVolumeSource is an autogenerated conversion function.
func Convert_core_CephFSVolumeSource_To_v1_CephFSVolumeSource(in *core.CephFSVolumeSource, out *corev1.CephFSVolumeSource, s conversion.Scope) error {
        return autoConvert_core_CephFSVolumeSource_To_v1_CephFSVolumeSource(in, out, s)
}

func autoConvert_v1_CinderPersistentVolumeSource_To_core_CinderPersistentVolumeSource(in *corev1.CinderPersistentVolumeSource, out *core.CinderPersistentVolumeSource, s conversion.Scope) error {
        out.VolumeID = in.VolumeID
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.SecretRef = (*core.SecretReference)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_v1_CinderPersistentVolumeSource_To_core_CinderPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_CinderPersistentVolumeSource_To_core_CinderPersistentVolumeSource(in *corev1.CinderPersistentVolumeSource, out *core.CinderPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_CinderPersistentVolumeSource_To_core_CinderPersistentVolumeSource(in, out, s)
}

func autoConvert_core_CinderPersistentVolumeSource_To_v1_CinderPersistentVolumeSource(in *core.CinderPersistentVolumeSource, out *corev1.CinderPersistentVolumeSource, s conversion.Scope) error {
        out.VolumeID = in.VolumeID
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.SecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_core_CinderPersistentVolumeSource_To_v1_CinderPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_CinderPersistentVolumeSource_To_v1_CinderPersistentVolumeSource(in *core.CinderPersistentVolumeSource, out *corev1.CinderPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_CinderPersistentVolumeSource_To_v1_CinderPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_CinderVolumeSource_To_core_CinderVolumeSource(in *corev1.CinderVolumeSource, out *core.CinderVolumeSource, s conversion.Scope) error {
        out.VolumeID = in.VolumeID
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.SecretRef = (*core.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_v1_CinderVolumeSource_To_core_CinderVolumeSource is an autogenerated conversion function.
func Convert_v1_CinderVolumeSource_To_core_CinderVolumeSource(in *corev1.CinderVolumeSource, out *core.CinderVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_CinderVolumeSource_To_core_CinderVolumeSource(in, out, s)
}

func autoConvert_core_CinderVolumeSource_To_v1_CinderVolumeSource(in *core.CinderVolumeSource, out *corev1.CinderVolumeSource, s conversion.Scope) error {
        out.VolumeID = in.VolumeID
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.SecretRef = (*corev1.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_core_CinderVolumeSource_To_v1_CinderVolumeSource is an autogenerated conversion function.
func Convert_core_CinderVolumeSource_To_v1_CinderVolumeSource(in *core.CinderVolumeSource, out *corev1.CinderVolumeSource, s conversion.Scope) error {
        return autoConvert_core_CinderVolumeSource_To_v1_CinderVolumeSource(in, out, s)
}

func autoConvert_v1_ClientIPConfig_To_core_ClientIPConfig(in *corev1.ClientIPConfig, out *core.ClientIPConfig, s conversion.Scope) error {
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        return nil
}

// Convert_v1_ClientIPConfig_To_core_ClientIPConfig is an autogenerated conversion function.
func Convert_v1_ClientIPConfig_To_core_ClientIPConfig(in *corev1.ClientIPConfig, out *core.ClientIPConfig, s conversion.Scope) error {
        return autoConvert_v1_ClientIPConfig_To_core_ClientIPConfig(in, out, s)
}

func autoConvert_core_ClientIPConfig_To_v1_ClientIPConfig(in *core.ClientIPConfig, out *corev1.ClientIPConfig, s conversion.Scope) error {
        out.TimeoutSeconds = (*int32)(unsafe.Pointer(in.TimeoutSeconds))
        return nil
}

// Convert_core_ClientIPConfig_To_v1_ClientIPConfig is an autogenerated conversion function.
func Convert_core_ClientIPConfig_To_v1_ClientIPConfig(in *core.ClientIPConfig, out *corev1.ClientIPConfig, s conversion.Scope) error {
        return autoConvert_core_ClientIPConfig_To_v1_ClientIPConfig(in, out, s)
}

func autoConvert_v1_ClusterTrustBundleProjection_To_core_ClusterTrustBundleProjection(in *corev1.ClusterTrustBundleProjection, out *core.ClusterTrustBundleProjection, s conversion.Scope) error {
        out.Name = (*string)(unsafe.Pointer(in.Name))
        out.SignerName = (*string)(unsafe.Pointer(in.SignerName))
        out.LabelSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.LabelSelector))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        out.Path = in.Path
        return nil
}

// Convert_v1_ClusterTrustBundleProjection_To_core_ClusterTrustBundleProjection is an autogenerated conversion function.
func Convert_v1_ClusterTrustBundleProjection_To_core_ClusterTrustBundleProjection(in *corev1.ClusterTrustBundleProjection, out *core.ClusterTrustBundleProjection, s conversion.Scope) error {
        return autoConvert_v1_ClusterTrustBundleProjection_To_core_ClusterTrustBundleProjection(in, out, s)
}

func autoConvert_core_ClusterTrustBundleProjection_To_v1_ClusterTrustBundleProjection(in *core.ClusterTrustBundleProjection, out *corev1.ClusterTrustBundleProjection, s conversion.Scope) error {
        out.Name = (*string)(unsafe.Pointer(in.Name))
        out.SignerName = (*string)(unsafe.Pointer(in.SignerName))
        out.LabelSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.LabelSelector))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        out.Path = in.Path
        return nil
}

// Convert_core_ClusterTrustBundleProjection_To_v1_ClusterTrustBundleProjection is an autogenerated conversion function.
func Convert_core_ClusterTrustBundleProjection_To_v1_ClusterTrustBundleProjection(in *core.ClusterTrustBundleProjection, out *corev1.ClusterTrustBundleProjection, s conversion.Scope) error {
        return autoConvert_core_ClusterTrustBundleProjection_To_v1_ClusterTrustBundleProjection(in, out, s)
}

func autoConvert_v1_ComponentCondition_To_core_ComponentCondition(in *corev1.ComponentCondition, out *core.ComponentCondition, s conversion.Scope) error {
        out.Type = core.ComponentConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.Message = in.Message
        out.Error = in.Error
        return nil
}

// Convert_v1_ComponentCondition_To_core_ComponentCondition is an autogenerated conversion function.
func Convert_v1_ComponentCondition_To_core_ComponentCondition(in *corev1.ComponentCondition, out *core.ComponentCondition, s conversion.Scope) error {
        return autoConvert_v1_ComponentCondition_To_core_ComponentCondition(in, out, s)
}

func autoConvert_core_ComponentCondition_To_v1_ComponentCondition(in *core.ComponentCondition, out *corev1.ComponentCondition, s conversion.Scope) error {
        out.Type = corev1.ComponentConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.Message = in.Message
        out.Error = in.Error
        return nil
}

// Convert_core_ComponentCondition_To_v1_ComponentCondition is an autogenerated conversion function.
func Convert_core_ComponentCondition_To_v1_ComponentCondition(in *core.ComponentCondition, out *corev1.ComponentCondition, s conversion.Scope) error {
        return autoConvert_core_ComponentCondition_To_v1_ComponentCondition(in, out, s)
}

func autoConvert_v1_ComponentStatus_To_core_ComponentStatus(in *corev1.ComponentStatus, out *core.ComponentStatus, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Conditions = *(*[]core.ComponentCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1_ComponentStatus_To_core_ComponentStatus is an autogenerated conversion function.
func Convert_v1_ComponentStatus_To_core_ComponentStatus(in *corev1.ComponentStatus, out *core.ComponentStatus, s conversion.Scope) error {
        return autoConvert_v1_ComponentStatus_To_core_ComponentStatus(in, out, s)
}

func autoConvert_core_ComponentStatus_To_v1_ComponentStatus(in *core.ComponentStatus, out *corev1.ComponentStatus, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Conditions = *(*[]corev1.ComponentCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_core_ComponentStatus_To_v1_ComponentStatus is an autogenerated conversion function.
func Convert_core_ComponentStatus_To_v1_ComponentStatus(in *core.ComponentStatus, out *corev1.ComponentStatus, s conversion.Scope) error {
        return autoConvert_core_ComponentStatus_To_v1_ComponentStatus(in, out, s)
}

func autoConvert_v1_ComponentStatusList_To_core_ComponentStatusList(in *corev1.ComponentStatusList, out *core.ComponentStatusList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.ComponentStatus)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_ComponentStatusList_To_core_ComponentStatusList is an autogenerated conversion function.
func Convert_v1_ComponentStatusList_To_core_ComponentStatusList(in *corev1.ComponentStatusList, out *core.ComponentStatusList, s conversion.Scope) error {
        return autoConvert_v1_ComponentStatusList_To_core_ComponentStatusList(in, out, s)
}

func autoConvert_core_ComponentStatusList_To_v1_ComponentStatusList(in *core.ComponentStatusList, out *corev1.ComponentStatusList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.ComponentStatus)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_ComponentStatusList_To_v1_ComponentStatusList is an autogenerated conversion function.
func Convert_core_ComponentStatusList_To_v1_ComponentStatusList(in *core.ComponentStatusList, out *corev1.ComponentStatusList, s conversion.Scope) error {
        return autoConvert_core_ComponentStatusList_To_v1_ComponentStatusList(in, out, s)
}

func autoConvert_v1_ConfigMap_To_core_ConfigMap(in *corev1.ConfigMap, out *core.ConfigMap, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Immutable = (*bool)(unsafe.Pointer(in.Immutable))
        out.Data = *(*map[string]string)(unsafe.Pointer(&in.Data))
        out.BinaryData = *(*map[string][]byte)(unsafe.Pointer(&in.BinaryData))
        return nil
}

// Convert_v1_ConfigMap_To_core_ConfigMap is an autogenerated conversion function.
func Convert_v1_ConfigMap_To_core_ConfigMap(in *corev1.ConfigMap, out *core.ConfigMap, s conversion.Scope) error {
        return autoConvert_v1_ConfigMap_To_core_ConfigMap(in, out, s)
}

func autoConvert_core_ConfigMap_To_v1_ConfigMap(in *core.ConfigMap, out *corev1.ConfigMap, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Immutable = (*bool)(unsafe.Pointer(in.Immutable))
        out.Data = *(*map[string]string)(unsafe.Pointer(&in.Data))
        out.BinaryData = *(*map[string][]byte)(unsafe.Pointer(&in.BinaryData))
        return nil
}

// Convert_core_ConfigMap_To_v1_ConfigMap is an autogenerated conversion function.
func Convert_core_ConfigMap_To_v1_ConfigMap(in *core.ConfigMap, out *corev1.ConfigMap, s conversion.Scope) error {
        return autoConvert_core_ConfigMap_To_v1_ConfigMap(in, out, s)
}

func autoConvert_v1_ConfigMapEnvSource_To_core_ConfigMapEnvSource(in *corev1.ConfigMapEnvSource, out *core.ConfigMapEnvSource, s conversion.Scope) error {
        if err := Convert_v1_LocalObjectReference_To_core_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_ConfigMapEnvSource_To_core_ConfigMapEnvSource is an autogenerated conversion function.
func Convert_v1_ConfigMapEnvSource_To_core_ConfigMapEnvSource(in *corev1.ConfigMapEnvSource, out *core.ConfigMapEnvSource, s conversion.Scope) error {
        return autoConvert_v1_ConfigMapEnvSource_To_core_ConfigMapEnvSource(in, out, s)
}

func autoConvert_core_ConfigMapEnvSource_To_v1_ConfigMapEnvSource(in *core.ConfigMapEnvSource, out *corev1.ConfigMapEnvSource, s conversion.Scope) error {
        if err := Convert_core_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_ConfigMapEnvSource_To_v1_ConfigMapEnvSource is an autogenerated conversion function.
func Convert_core_ConfigMapEnvSource_To_v1_ConfigMapEnvSource(in *core.ConfigMapEnvSource, out *corev1.ConfigMapEnvSource, s conversion.Scope) error {
        return autoConvert_core_ConfigMapEnvSource_To_v1_ConfigMapEnvSource(in, out, s)
}

func autoConvert_v1_ConfigMapKeySelector_To_core_ConfigMapKeySelector(in *corev1.ConfigMapKeySelector, out *core.ConfigMapKeySelector, s conversion.Scope) error {
        if err := Convert_v1_LocalObjectReference_To_core_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Key = in.Key
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_ConfigMapKeySelector_To_core_ConfigMapKeySelector is an autogenerated conversion function.
func Convert_v1_ConfigMapKeySelector_To_core_ConfigMapKeySelector(in *corev1.ConfigMapKeySelector, out *core.ConfigMapKeySelector, s conversion.Scope) error {
        return autoConvert_v1_ConfigMapKeySelector_To_core_ConfigMapKeySelector(in, out, s)
}

func autoConvert_core_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *core.ConfigMapKeySelector, out *corev1.ConfigMapKeySelector, s conversion.Scope) error {
        if err := Convert_core_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Key = in.Key
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_ConfigMapKeySelector_To_v1_ConfigMapKeySelector is an autogenerated conversion function.
func Convert_core_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in *core.ConfigMapKeySelector, out *corev1.ConfigMapKeySelector, s conversion.Scope) error {
        return autoConvert_core_ConfigMapKeySelector_To_v1_ConfigMapKeySelector(in, out, s)
}

func autoConvert_v1_ConfigMapList_To_core_ConfigMapList(in *corev1.ConfigMapList, out *core.ConfigMapList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.ConfigMap)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_ConfigMapList_To_core_ConfigMapList is an autogenerated conversion function.
func Convert_v1_ConfigMapList_To_core_ConfigMapList(in *corev1.ConfigMapList, out *core.ConfigMapList, s conversion.Scope) error {
        return autoConvert_v1_ConfigMapList_To_core_ConfigMapList(in, out, s)
}

func autoConvert_core_ConfigMapList_To_v1_ConfigMapList(in *core.ConfigMapList, out *corev1.ConfigMapList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.ConfigMap)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_ConfigMapList_To_v1_ConfigMapList is an autogenerated conversion function.
func Convert_core_ConfigMapList_To_v1_ConfigMapList(in *core.ConfigMapList, out *corev1.ConfigMapList, s conversion.Scope) error {
        return autoConvert_core_ConfigMapList_To_v1_ConfigMapList(in, out, s)
}

func autoConvert_v1_ConfigMapNodeConfigSource_To_core_ConfigMapNodeConfigSource(in *corev1.ConfigMapNodeConfigSource, out *core.ConfigMapNodeConfigSource, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Name = in.Name
        out.UID = types.UID(in.UID)
        out.ResourceVersion = in.ResourceVersion
        out.KubeletConfigKey = in.KubeletConfigKey
        return nil
}

// Convert_v1_ConfigMapNodeConfigSource_To_core_ConfigMapNodeConfigSource is an autogenerated conversion function.
func Convert_v1_ConfigMapNodeConfigSource_To_core_ConfigMapNodeConfigSource(in *corev1.ConfigMapNodeConfigSource, out *core.ConfigMapNodeConfigSource, s conversion.Scope) error {
        return autoConvert_v1_ConfigMapNodeConfigSource_To_core_ConfigMapNodeConfigSource(in, out, s)
}

func autoConvert_core_ConfigMapNodeConfigSource_To_v1_ConfigMapNodeConfigSource(in *core.ConfigMapNodeConfigSource, out *corev1.ConfigMapNodeConfigSource, s conversion.Scope) error {
        out.Namespace = in.Namespace
        out.Name = in.Name
        out.UID = types.UID(in.UID)
        out.ResourceVersion = in.ResourceVersion
        out.KubeletConfigKey = in.KubeletConfigKey
        return nil
}

// Convert_core_ConfigMapNodeConfigSource_To_v1_ConfigMapNodeConfigSource is an autogenerated conversion function.
func Convert_core_ConfigMapNodeConfigSource_To_v1_ConfigMapNodeConfigSource(in *core.ConfigMapNodeConfigSource, out *corev1.ConfigMapNodeConfigSource, s conversion.Scope) error {
        return autoConvert_core_ConfigMapNodeConfigSource_To_v1_ConfigMapNodeConfigSource(in, out, s)
}

func autoConvert_v1_ConfigMapProjection_To_core_ConfigMapProjection(in *corev1.ConfigMapProjection, out *core.ConfigMapProjection, s conversion.Scope) error {
        if err := Convert_v1_LocalObjectReference_To_core_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Items = *(*[]core.KeyToPath)(unsafe.Pointer(&in.Items))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_ConfigMapProjection_To_core_ConfigMapProjection is an autogenerated conversion function.
func Convert_v1_ConfigMapProjection_To_core_ConfigMapProjection(in *corev1.ConfigMapProjection, out *core.ConfigMapProjection, s conversion.Scope) error {
        return autoConvert_v1_ConfigMapProjection_To_core_ConfigMapProjection(in, out, s)
}

func autoConvert_core_ConfigMapProjection_To_v1_ConfigMapProjection(in *core.ConfigMapProjection, out *corev1.ConfigMapProjection, s conversion.Scope) error {
        if err := Convert_core_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Items = *(*[]corev1.KeyToPath)(unsafe.Pointer(&in.Items))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_ConfigMapProjection_To_v1_ConfigMapProjection is an autogenerated conversion function.
func Convert_core_ConfigMapProjection_To_v1_ConfigMapProjection(in *core.ConfigMapProjection, out *corev1.ConfigMapProjection, s conversion.Scope) error {
        return autoConvert_core_ConfigMapProjection_To_v1_ConfigMapProjection(in, out, s)
}

func autoConvert_v1_ConfigMapVolumeSource_To_core_ConfigMapVolumeSource(in *corev1.ConfigMapVolumeSource, out *core.ConfigMapVolumeSource, s conversion.Scope) error {
        if err := Convert_v1_LocalObjectReference_To_core_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Items = *(*[]core.KeyToPath)(unsafe.Pointer(&in.Items))
        out.DefaultMode = (*int32)(unsafe.Pointer(in.DefaultMode))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_ConfigMapVolumeSource_To_core_ConfigMapVolumeSource is an autogenerated conversion function.
func Convert_v1_ConfigMapVolumeSource_To_core_ConfigMapVolumeSource(in *corev1.ConfigMapVolumeSource, out *core.ConfigMapVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_ConfigMapVolumeSource_To_core_ConfigMapVolumeSource(in, out, s)
}

func autoConvert_core_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *core.ConfigMapVolumeSource, out *corev1.ConfigMapVolumeSource, s conversion.Scope) error {
        if err := Convert_core_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Items = *(*[]corev1.KeyToPath)(unsafe.Pointer(&in.Items))
        out.DefaultMode = (*int32)(unsafe.Pointer(in.DefaultMode))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource is an autogenerated conversion function.
func Convert_core_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in *core.ConfigMapVolumeSource, out *corev1.ConfigMapVolumeSource, s conversion.Scope) error {
        return autoConvert_core_ConfigMapVolumeSource_To_v1_ConfigMapVolumeSource(in, out, s)
}

func autoConvert_v1_Container_To_core_Container(in *corev1.Container, out *core.Container, s conversion.Scope) error {
        out.Name = in.Name
        out.Image = in.Image
        out.Command = *(*[]string)(unsafe.Pointer(&in.Command))
        out.Args = *(*[]string)(unsafe.Pointer(&in.Args))
        out.WorkingDir = in.WorkingDir
        out.Ports = *(*[]core.ContainerPort)(unsafe.Pointer(&in.Ports))
        out.EnvFrom = *(*[]core.EnvFromSource)(unsafe.Pointer(&in.EnvFrom))
        out.Env = *(*[]core.EnvVar)(unsafe.Pointer(&in.Env))
        if err := Convert_v1_ResourceRequirements_To_core_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
                return err
        }
        out.ResizePolicy = *(*[]core.ContainerResizePolicy)(unsafe.Pointer(&in.ResizePolicy))
        out.RestartPolicy = (*core.ContainerRestartPolicy)(unsafe.Pointer(in.RestartPolicy))
        out.RestartPolicyRules = *(*[]core.ContainerRestartRule)(unsafe.Pointer(&in.RestartPolicyRules))
        out.VolumeMounts = *(*[]core.VolumeMount)(unsafe.Pointer(&in.VolumeMounts))
        out.VolumeDevices = *(*[]core.VolumeDevice)(unsafe.Pointer(&in.VolumeDevices))
        out.LivenessProbe = (*core.Probe)(unsafe.Pointer(in.LivenessProbe))
        out.ReadinessProbe = (*core.Probe)(unsafe.Pointer(in.ReadinessProbe))
        out.StartupProbe = (*core.Probe)(unsafe.Pointer(in.StartupProbe))
        out.Lifecycle = (*core.Lifecycle)(unsafe.Pointer(in.Lifecycle))
        out.TerminationMessagePath = in.TerminationMessagePath
        out.TerminationMessagePolicy = core.TerminationMessagePolicy(in.TerminationMessagePolicy)
        out.ImagePullPolicy = core.PullPolicy(in.ImagePullPolicy)
        out.SecurityContext = (*core.SecurityContext)(unsafe.Pointer(in.SecurityContext))
        out.Stdin = in.Stdin
        out.StdinOnce = in.StdinOnce
        out.TTY = in.TTY
        return nil
}

// Convert_v1_Container_To_core_Container is an autogenerated conversion function.
func Convert_v1_Container_To_core_Container(in *corev1.Container, out *core.Container, s conversion.Scope) error {
        return autoConvert_v1_Container_To_core_Container(in, out, s)
}

func autoConvert_core_Container_To_v1_Container(in *core.Container, out *corev1.Container, s conversion.Scope) error {
        out.Name = in.Name
        out.Image = in.Image
        out.Command = *(*[]string)(unsafe.Pointer(&in.Command))
        out.Args = *(*[]string)(unsafe.Pointer(&in.Args))
        out.WorkingDir = in.WorkingDir
        out.Ports = *(*[]corev1.ContainerPort)(unsafe.Pointer(&in.Ports))
        out.EnvFrom = *(*[]corev1.EnvFromSource)(unsafe.Pointer(&in.EnvFrom))
        out.Env = *(*[]corev1.EnvVar)(unsafe.Pointer(&in.Env))
        if err := Convert_core_ResourceRequirements_To_v1_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
                return err
        }
        out.ResizePolicy = *(*[]corev1.ContainerResizePolicy)(unsafe.Pointer(&in.ResizePolicy))
        out.RestartPolicy = (*corev1.ContainerRestartPolicy)(unsafe.Pointer(in.RestartPolicy))
        out.RestartPolicyRules = *(*[]corev1.ContainerRestartRule)(unsafe.Pointer(&in.RestartPolicyRules))
        out.VolumeMounts = *(*[]corev1.VolumeMount)(unsafe.Pointer(&in.VolumeMounts))
        out.VolumeDevices = *(*[]corev1.VolumeDevice)(unsafe.Pointer(&in.VolumeDevices))
        out.LivenessProbe = (*corev1.Probe)(unsafe.Pointer(in.LivenessProbe))
        out.ReadinessProbe = (*corev1.Probe)(unsafe.Pointer(in.ReadinessProbe))
        out.StartupProbe = (*corev1.Probe)(unsafe.Pointer(in.StartupProbe))
        out.Lifecycle = (*corev1.Lifecycle)(unsafe.Pointer(in.Lifecycle))
        out.TerminationMessagePath = in.TerminationMessagePath
        out.TerminationMessagePolicy = corev1.TerminationMessagePolicy(in.TerminationMessagePolicy)
        out.ImagePullPolicy = corev1.PullPolicy(in.ImagePullPolicy)
        out.SecurityContext = (*corev1.SecurityContext)(unsafe.Pointer(in.SecurityContext))
        out.Stdin = in.Stdin
        out.StdinOnce = in.StdinOnce
        out.TTY = in.TTY
        return nil
}

// Convert_core_Container_To_v1_Container is an autogenerated conversion function.
func Convert_core_Container_To_v1_Container(in *core.Container, out *corev1.Container, s conversion.Scope) error {
        return autoConvert_core_Container_To_v1_Container(in, out, s)
}

func autoConvert_v1_ContainerExtendedResourceRequest_To_core_ContainerExtendedResourceRequest(in *corev1.ContainerExtendedResourceRequest, out *core.ContainerExtendedResourceRequest, s conversion.Scope) error {
        out.ContainerName = in.ContainerName
        out.ResourceName = in.ResourceName
        out.RequestName = in.RequestName
        return nil
}

// Convert_v1_ContainerExtendedResourceRequest_To_core_ContainerExtendedResourceRequest is an autogenerated conversion function.
func Convert_v1_ContainerExtendedResourceRequest_To_core_ContainerExtendedResourceRequest(in *corev1.ContainerExtendedResourceRequest, out *core.ContainerExtendedResourceRequest, s conversion.Scope) error {
        return autoConvert_v1_ContainerExtendedResourceRequest_To_core_ContainerExtendedResourceRequest(in, out, s)
}

func autoConvert_core_ContainerExtendedResourceRequest_To_v1_ContainerExtendedResourceRequest(in *core.ContainerExtendedResourceRequest, out *corev1.ContainerExtendedResourceRequest, s conversion.Scope) error {
        out.ContainerName = in.ContainerName
        out.ResourceName = in.ResourceName
        out.RequestName = in.RequestName
        return nil
}

// Convert_core_ContainerExtendedResourceRequest_To_v1_ContainerExtendedResourceRequest is an autogenerated conversion function.
func Convert_core_ContainerExtendedResourceRequest_To_v1_ContainerExtendedResourceRequest(in *core.ContainerExtendedResourceRequest, out *corev1.ContainerExtendedResourceRequest, s conversion.Scope) error {
        return autoConvert_core_ContainerExtendedResourceRequest_To_v1_ContainerExtendedResourceRequest(in, out, s)
}

func autoConvert_v1_ContainerImage_To_core_ContainerImage(in *corev1.ContainerImage, out *core.ContainerImage, s conversion.Scope) error {
        out.Names = *(*[]string)(unsafe.Pointer(&in.Names))
        out.SizeBytes = in.SizeBytes
        return nil
}

// Convert_v1_ContainerImage_To_core_ContainerImage is an autogenerated conversion function.
func Convert_v1_ContainerImage_To_core_ContainerImage(in *corev1.ContainerImage, out *core.ContainerImage, s conversion.Scope) error {
        return autoConvert_v1_ContainerImage_To_core_ContainerImage(in, out, s)
}

func autoConvert_core_ContainerImage_To_v1_ContainerImage(in *core.ContainerImage, out *corev1.ContainerImage, s conversion.Scope) error {
        out.Names = *(*[]string)(unsafe.Pointer(&in.Names))
        out.SizeBytes = in.SizeBytes
        return nil
}

// Convert_core_ContainerImage_To_v1_ContainerImage is an autogenerated conversion function.
func Convert_core_ContainerImage_To_v1_ContainerImage(in *core.ContainerImage, out *corev1.ContainerImage, s conversion.Scope) error {
        return autoConvert_core_ContainerImage_To_v1_ContainerImage(in, out, s)
}

func autoConvert_v1_ContainerPort_To_core_ContainerPort(in *corev1.ContainerPort, out *core.ContainerPort, s conversion.Scope) error {
        out.Name = in.Name
        out.HostPort = in.HostPort
        out.ContainerPort = in.ContainerPort
        out.Protocol = core.Protocol(in.Protocol)
        out.HostIP = in.HostIP
        return nil
}

// Convert_v1_ContainerPort_To_core_ContainerPort is an autogenerated conversion function.
func Convert_v1_ContainerPort_To_core_ContainerPort(in *corev1.ContainerPort, out *core.ContainerPort, s conversion.Scope) error {
        return autoConvert_v1_ContainerPort_To_core_ContainerPort(in, out, s)
}

func autoConvert_core_ContainerPort_To_v1_ContainerPort(in *core.ContainerPort, out *corev1.ContainerPort, s conversion.Scope) error {
        out.Name = in.Name
        out.HostPort = in.HostPort
        out.ContainerPort = in.ContainerPort
        out.Protocol = corev1.Protocol(in.Protocol)
        out.HostIP = in.HostIP
        return nil
}

// Convert_core_ContainerPort_To_v1_ContainerPort is an autogenerated conversion function.
func Convert_core_ContainerPort_To_v1_ContainerPort(in *core.ContainerPort, out *corev1.ContainerPort, s conversion.Scope) error {
        return autoConvert_core_ContainerPort_To_v1_ContainerPort(in, out, s)
}

func autoConvert_v1_ContainerResizePolicy_To_core_ContainerResizePolicy(in *corev1.ContainerResizePolicy, out *core.ContainerResizePolicy, s conversion.Scope) error {
        out.ResourceName = core.ResourceName(in.ResourceName)
        out.RestartPolicy = core.ResourceResizeRestartPolicy(in.RestartPolicy)
        return nil
}

// Convert_v1_ContainerResizePolicy_To_core_ContainerResizePolicy is an autogenerated conversion function.
func Convert_v1_ContainerResizePolicy_To_core_ContainerResizePolicy(in *corev1.ContainerResizePolicy, out *core.ContainerResizePolicy, s conversion.Scope) error {
        return autoConvert_v1_ContainerResizePolicy_To_core_ContainerResizePolicy(in, out, s)
}

func autoConvert_core_ContainerResizePolicy_To_v1_ContainerResizePolicy(in *core.ContainerResizePolicy, out *corev1.ContainerResizePolicy, s conversion.Scope) error {
        out.ResourceName = corev1.ResourceName(in.ResourceName)
        out.RestartPolicy = corev1.ResourceResizeRestartPolicy(in.RestartPolicy)
        return nil
}

// Convert_core_ContainerResizePolicy_To_v1_ContainerResizePolicy is an autogenerated conversion function.
func Convert_core_ContainerResizePolicy_To_v1_ContainerResizePolicy(in *core.ContainerResizePolicy, out *corev1.ContainerResizePolicy, s conversion.Scope) error {
        return autoConvert_core_ContainerResizePolicy_To_v1_ContainerResizePolicy(in, out, s)
}

func autoConvert_v1_ContainerRestartRule_To_core_ContainerRestartRule(in *corev1.ContainerRestartRule, out *core.ContainerRestartRule, s conversion.Scope) error {
        out.Action = core.ContainerRestartRuleAction(in.Action)
        out.ExitCodes = (*core.ContainerRestartRuleOnExitCodes)(unsafe.Pointer(in.ExitCodes))
        return nil
}

// Convert_v1_ContainerRestartRule_To_core_ContainerRestartRule is an autogenerated conversion function.
func Convert_v1_ContainerRestartRule_To_core_ContainerRestartRule(in *corev1.ContainerRestartRule, out *core.ContainerRestartRule, s conversion.Scope) error {
        return autoConvert_v1_ContainerRestartRule_To_core_ContainerRestartRule(in, out, s)
}

func autoConvert_core_ContainerRestartRule_To_v1_ContainerRestartRule(in *core.ContainerRestartRule, out *corev1.ContainerRestartRule, s conversion.Scope) error {
        out.Action = corev1.ContainerRestartRuleAction(in.Action)
        out.ExitCodes = (*corev1.ContainerRestartRuleOnExitCodes)(unsafe.Pointer(in.ExitCodes))
        return nil
}

// Convert_core_ContainerRestartRule_To_v1_ContainerRestartRule is an autogenerated conversion function.
func Convert_core_ContainerRestartRule_To_v1_ContainerRestartRule(in *core.ContainerRestartRule, out *corev1.ContainerRestartRule, s conversion.Scope) error {
        return autoConvert_core_ContainerRestartRule_To_v1_ContainerRestartRule(in, out, s)
}

func autoConvert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes(in *corev1.ContainerRestartRuleOnExitCodes, out *core.ContainerRestartRuleOnExitCodes, s conversion.Scope) error {
        out.Operator = core.ContainerRestartRuleOnExitCodesOperator(in.Operator)
        out.Values = *(*[]int32)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes is an autogenerated conversion function.
func Convert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes(in *corev1.ContainerRestartRuleOnExitCodes, out *core.ContainerRestartRuleOnExitCodes, s conversion.Scope) error {
        return autoConvert_v1_ContainerRestartRuleOnExitCodes_To_core_ContainerRestartRuleOnExitCodes(in, out, s)
}

func autoConvert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes(in *core.ContainerRestartRuleOnExitCodes, out *corev1.ContainerRestartRuleOnExitCodes, s conversion.Scope) error {
        out.Operator = corev1.ContainerRestartRuleOnExitCodesOperator(in.Operator)
        out.Values = *(*[]int32)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes is an autogenerated conversion function.
func Convert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes(in *core.ContainerRestartRuleOnExitCodes, out *corev1.ContainerRestartRuleOnExitCodes, s conversion.Scope) error {
        return autoConvert_core_ContainerRestartRuleOnExitCodes_To_v1_ContainerRestartRuleOnExitCodes(in, out, s)
}

func autoConvert_v1_ContainerState_To_core_ContainerState(in *corev1.ContainerState, out *core.ContainerState, s conversion.Scope) error {
        out.Waiting = (*core.ContainerStateWaiting)(unsafe.Pointer(in.Waiting))
        out.Running = (*core.ContainerStateRunning)(unsafe.Pointer(in.Running))
        out.Terminated = (*core.ContainerStateTerminated)(unsafe.Pointer(in.Terminated))
        return nil
}

// Convert_v1_ContainerState_To_core_ContainerState is an autogenerated conversion function.
func Convert_v1_ContainerState_To_core_ContainerState(in *corev1.ContainerState, out *core.ContainerState, s conversion.Scope) error {
        return autoConvert_v1_ContainerState_To_core_ContainerState(in, out, s)
}

func autoConvert_core_ContainerState_To_v1_ContainerState(in *core.ContainerState, out *corev1.ContainerState, s conversion.Scope) error {
        out.Waiting = (*corev1.ContainerStateWaiting)(unsafe.Pointer(in.Waiting))
        out.Running = (*corev1.ContainerStateRunning)(unsafe.Pointer(in.Running))
        out.Terminated = (*corev1.ContainerStateTerminated)(unsafe.Pointer(in.Terminated))
        return nil
}

// Convert_core_ContainerState_To_v1_ContainerState is an autogenerated conversion function.
func Convert_core_ContainerState_To_v1_ContainerState(in *core.ContainerState, out *corev1.ContainerState, s conversion.Scope) error {
        return autoConvert_core_ContainerState_To_v1_ContainerState(in, out, s)
}

func autoConvert_v1_ContainerStateRunning_To_core_ContainerStateRunning(in *corev1.ContainerStateRunning, out *core.ContainerStateRunning, s conversion.Scope) error {
        out.StartedAt = in.StartedAt
        return nil
}

// Convert_v1_ContainerStateRunning_To_core_ContainerStateRunning is an autogenerated conversion function.
func Convert_v1_ContainerStateRunning_To_core_ContainerStateRunning(in *corev1.ContainerStateRunning, out *core.ContainerStateRunning, s conversion.Scope) error {
        return autoConvert_v1_ContainerStateRunning_To_core_ContainerStateRunning(in, out, s)
}

func autoConvert_core_ContainerStateRunning_To_v1_ContainerStateRunning(in *core.ContainerStateRunning, out *corev1.ContainerStateRunning, s conversion.Scope) error {
        out.StartedAt = in.StartedAt
        return nil
}

// Convert_core_ContainerStateRunning_To_v1_ContainerStateRunning is an autogenerated conversion function.
func Convert_core_ContainerStateRunning_To_v1_ContainerStateRunning(in *core.ContainerStateRunning, out *corev1.ContainerStateRunning, s conversion.Scope) error {
        return autoConvert_core_ContainerStateRunning_To_v1_ContainerStateRunning(in, out, s)
}

func autoConvert_v1_ContainerStateTerminated_To_core_ContainerStateTerminated(in *corev1.ContainerStateTerminated, out *core.ContainerStateTerminated, s conversion.Scope) error {
        out.ExitCode = in.ExitCode
        out.Signal = in.Signal
        out.Reason = in.Reason
        out.Message = in.Message
        out.StartedAt = in.StartedAt
        out.FinishedAt = in.FinishedAt
        out.ContainerID = in.ContainerID
        return nil
}

// Convert_v1_ContainerStateTerminated_To_core_ContainerStateTerminated is an autogenerated conversion function.
func Convert_v1_ContainerStateTerminated_To_core_ContainerStateTerminated(in *corev1.ContainerStateTerminated, out *core.ContainerStateTerminated, s conversion.Scope) error {
        return autoConvert_v1_ContainerStateTerminated_To_core_ContainerStateTerminated(in, out, s)
}

func autoConvert_core_ContainerStateTerminated_To_v1_ContainerStateTerminated(in *core.ContainerStateTerminated, out *corev1.ContainerStateTerminated, s conversion.Scope) error {
        out.ExitCode = in.ExitCode
        out.Signal = in.Signal
        out.Reason = in.Reason
        out.Message = in.Message
        out.StartedAt = in.StartedAt
        out.FinishedAt = in.FinishedAt
        out.ContainerID = in.ContainerID
        return nil
}

// Convert_core_ContainerStateTerminated_To_v1_ContainerStateTerminated is an autogenerated conversion function.
func Convert_core_ContainerStateTerminated_To_v1_ContainerStateTerminated(in *core.ContainerStateTerminated, out *corev1.ContainerStateTerminated, s conversion.Scope) error {
        return autoConvert_core_ContainerStateTerminated_To_v1_ContainerStateTerminated(in, out, s)
}

func autoConvert_v1_ContainerStateWaiting_To_core_ContainerStateWaiting(in *corev1.ContainerStateWaiting, out *core.ContainerStateWaiting, s conversion.Scope) error {
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_ContainerStateWaiting_To_core_ContainerStateWaiting is an autogenerated conversion function.
func Convert_v1_ContainerStateWaiting_To_core_ContainerStateWaiting(in *corev1.ContainerStateWaiting, out *core.ContainerStateWaiting, s conversion.Scope) error {
        return autoConvert_v1_ContainerStateWaiting_To_core_ContainerStateWaiting(in, out, s)
}

func autoConvert_core_ContainerStateWaiting_To_v1_ContainerStateWaiting(in *core.ContainerStateWaiting, out *corev1.ContainerStateWaiting, s conversion.Scope) error {
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_core_ContainerStateWaiting_To_v1_ContainerStateWaiting is an autogenerated conversion function.
func Convert_core_ContainerStateWaiting_To_v1_ContainerStateWaiting(in *core.ContainerStateWaiting, out *corev1.ContainerStateWaiting, s conversion.Scope) error {
        return autoConvert_core_ContainerStateWaiting_To_v1_ContainerStateWaiting(in, out, s)
}

func autoConvert_v1_ContainerStatus_To_core_ContainerStatus(in *corev1.ContainerStatus, out *core.ContainerStatus, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_v1_ContainerState_To_core_ContainerState(&in.State, &out.State, s); err != nil {
                return err
        }
        if err := Convert_v1_ContainerState_To_core_ContainerState(&in.LastTerminationState, &out.LastTerminationState, s); err != nil {
                return err
        }
        out.Ready = in.Ready
        out.RestartCount = in.RestartCount
        out.Image = in.Image
        out.ImageID = in.ImageID
        out.ContainerID = in.ContainerID
        out.Started = (*bool)(unsafe.Pointer(in.Started))
        out.AllocatedResources = *(*core.ResourceList)(unsafe.Pointer(&in.AllocatedResources))
        out.Resources = (*core.ResourceRequirements)(unsafe.Pointer(in.Resources))
        out.VolumeMounts = *(*[]core.VolumeMountStatus)(unsafe.Pointer(&in.VolumeMounts))
        out.User = (*core.ContainerUser)(unsafe.Pointer(in.User))
        out.AllocatedResourcesStatus = *(*[]core.ResourceStatus)(unsafe.Pointer(&in.AllocatedResourcesStatus))
        out.StopSignal = (*core.Signal)(unsafe.Pointer(in.StopSignal))
        return nil
}

// Convert_v1_ContainerStatus_To_core_ContainerStatus is an autogenerated conversion function.
func Convert_v1_ContainerStatus_To_core_ContainerStatus(in *corev1.ContainerStatus, out *core.ContainerStatus, s conversion.Scope) error {
        return autoConvert_v1_ContainerStatus_To_core_ContainerStatus(in, out, s)
}

func autoConvert_core_ContainerStatus_To_v1_ContainerStatus(in *core.ContainerStatus, out *corev1.ContainerStatus, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_core_ContainerState_To_v1_ContainerState(&in.State, &out.State, s); err != nil {
                return err
        }
        if err := Convert_core_ContainerState_To_v1_ContainerState(&in.LastTerminationState, &out.LastTerminationState, s); err != nil {
                return err
        }
        out.Ready = in.Ready
        out.RestartCount = in.RestartCount
        out.Image = in.Image
        out.ImageID = in.ImageID
        out.ContainerID = in.ContainerID
        out.Started = (*bool)(unsafe.Pointer(in.Started))
        out.AllocatedResources = *(*corev1.ResourceList)(unsafe.Pointer(&in.AllocatedResources))
        out.Resources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.Resources))
        out.VolumeMounts = *(*[]corev1.VolumeMountStatus)(unsafe.Pointer(&in.VolumeMounts))
        out.User = (*corev1.ContainerUser)(unsafe.Pointer(in.User))
        out.AllocatedResourcesStatus = *(*[]corev1.ResourceStatus)(unsafe.Pointer(&in.AllocatedResourcesStatus))
        out.StopSignal = (*corev1.Signal)(unsafe.Pointer(in.StopSignal))
        return nil
}

// Convert_core_ContainerStatus_To_v1_ContainerStatus is an autogenerated conversion function.
func Convert_core_ContainerStatus_To_v1_ContainerStatus(in *core.ContainerStatus, out *corev1.ContainerStatus, s conversion.Scope) error {
        return autoConvert_core_ContainerStatus_To_v1_ContainerStatus(in, out, s)
}

func autoConvert_v1_ContainerUser_To_core_ContainerUser(in *corev1.ContainerUser, out *core.ContainerUser, s conversion.Scope) error {
        out.Linux = (*core.LinuxContainerUser)(unsafe.Pointer(in.Linux))
        return nil
}

// Convert_v1_ContainerUser_To_core_ContainerUser is an autogenerated conversion function.
func Convert_v1_ContainerUser_To_core_ContainerUser(in *corev1.ContainerUser, out *core.ContainerUser, s conversion.Scope) error {
        return autoConvert_v1_ContainerUser_To_core_ContainerUser(in, out, s)
}

func autoConvert_core_ContainerUser_To_v1_ContainerUser(in *core.ContainerUser, out *corev1.ContainerUser, s conversion.Scope) error {
        out.Linux = (*corev1.LinuxContainerUser)(unsafe.Pointer(in.Linux))
        return nil
}

// Convert_core_ContainerUser_To_v1_ContainerUser is an autogenerated conversion function.
func Convert_core_ContainerUser_To_v1_ContainerUser(in *core.ContainerUser, out *corev1.ContainerUser, s conversion.Scope) error {
        return autoConvert_core_ContainerUser_To_v1_ContainerUser(in, out, s)
}

func autoConvert_v1_DaemonEndpoint_To_core_DaemonEndpoint(in *corev1.DaemonEndpoint, out *core.DaemonEndpoint, s conversion.Scope) error {
        out.Port = in.Port
        return nil
}

// Convert_v1_DaemonEndpoint_To_core_DaemonEndpoint is an autogenerated conversion function.
func Convert_v1_DaemonEndpoint_To_core_DaemonEndpoint(in *corev1.DaemonEndpoint, out *core.DaemonEndpoint, s conversion.Scope) error {
        return autoConvert_v1_DaemonEndpoint_To_core_DaemonEndpoint(in, out, s)
}

func autoConvert_core_DaemonEndpoint_To_v1_DaemonEndpoint(in *core.DaemonEndpoint, out *corev1.DaemonEndpoint, s conversion.Scope) error {
        out.Port = in.Port
        return nil
}

// Convert_core_DaemonEndpoint_To_v1_DaemonEndpoint is an autogenerated conversion function.
func Convert_core_DaemonEndpoint_To_v1_DaemonEndpoint(in *core.DaemonEndpoint, out *corev1.DaemonEndpoint, s conversion.Scope) error {
        return autoConvert_core_DaemonEndpoint_To_v1_DaemonEndpoint(in, out, s)
}

func autoConvert_v1_DownwardAPIProjection_To_core_DownwardAPIProjection(in *corev1.DownwardAPIProjection, out *core.DownwardAPIProjection, s conversion.Scope) error {
        out.Items = *(*[]core.DownwardAPIVolumeFile)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_DownwardAPIProjection_To_core_DownwardAPIProjection is an autogenerated conversion function.
func Convert_v1_DownwardAPIProjection_To_core_DownwardAPIProjection(in *corev1.DownwardAPIProjection, out *core.DownwardAPIProjection, s conversion.Scope) error {
        return autoConvert_v1_DownwardAPIProjection_To_core_DownwardAPIProjection(in, out, s)
}

func autoConvert_core_DownwardAPIProjection_To_v1_DownwardAPIProjection(in *core.DownwardAPIProjection, out *corev1.DownwardAPIProjection, s conversion.Scope) error {
        out.Items = *(*[]corev1.DownwardAPIVolumeFile)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_DownwardAPIProjection_To_v1_DownwardAPIProjection is an autogenerated conversion function.
func Convert_core_DownwardAPIProjection_To_v1_DownwardAPIProjection(in *core.DownwardAPIProjection, out *corev1.DownwardAPIProjection, s conversion.Scope) error {
        return autoConvert_core_DownwardAPIProjection_To_v1_DownwardAPIProjection(in, out, s)
}

func autoConvert_v1_DownwardAPIVolumeFile_To_core_DownwardAPIVolumeFile(in *corev1.DownwardAPIVolumeFile, out *core.DownwardAPIVolumeFile, s conversion.Scope) error {
        out.Path = in.Path
        out.FieldRef = (*core.ObjectFieldSelector)(unsafe.Pointer(in.FieldRef))
        out.ResourceFieldRef = (*core.ResourceFieldSelector)(unsafe.Pointer(in.ResourceFieldRef))
        out.Mode = (*int32)(unsafe.Pointer(in.Mode))
        return nil
}

// Convert_v1_DownwardAPIVolumeFile_To_core_DownwardAPIVolumeFile is an autogenerated conversion function.
func Convert_v1_DownwardAPIVolumeFile_To_core_DownwardAPIVolumeFile(in *corev1.DownwardAPIVolumeFile, out *core.DownwardAPIVolumeFile, s conversion.Scope) error {
        return autoConvert_v1_DownwardAPIVolumeFile_To_core_DownwardAPIVolumeFile(in, out, s)
}

func autoConvert_core_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *core.DownwardAPIVolumeFile, out *corev1.DownwardAPIVolumeFile, s conversion.Scope) error {
        out.Path = in.Path
        out.FieldRef = (*corev1.ObjectFieldSelector)(unsafe.Pointer(in.FieldRef))
        out.ResourceFieldRef = (*corev1.ResourceFieldSelector)(unsafe.Pointer(in.ResourceFieldRef))
        out.Mode = (*int32)(unsafe.Pointer(in.Mode))
        return nil
}

// Convert_core_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile is an autogenerated conversion function.
func Convert_core_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in *core.DownwardAPIVolumeFile, out *corev1.DownwardAPIVolumeFile, s conversion.Scope) error {
        return autoConvert_core_DownwardAPIVolumeFile_To_v1_DownwardAPIVolumeFile(in, out, s)
}

func autoConvert_v1_DownwardAPIVolumeSource_To_core_DownwardAPIVolumeSource(in *corev1.DownwardAPIVolumeSource, out *core.DownwardAPIVolumeSource, s conversion.Scope) error {
        out.Items = *(*[]core.DownwardAPIVolumeFile)(unsafe.Pointer(&in.Items))
        out.DefaultMode = (*int32)(unsafe.Pointer(in.DefaultMode))
        return nil
}

// Convert_v1_DownwardAPIVolumeSource_To_core_DownwardAPIVolumeSource is an autogenerated conversion function.
func Convert_v1_DownwardAPIVolumeSource_To_core_DownwardAPIVolumeSource(in *corev1.DownwardAPIVolumeSource, out *core.DownwardAPIVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_DownwardAPIVolumeSource_To_core_DownwardAPIVolumeSource(in, out, s)
}

func autoConvert_core_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *core.DownwardAPIVolumeSource, out *corev1.DownwardAPIVolumeSource, s conversion.Scope) error {
        out.Items = *(*[]corev1.DownwardAPIVolumeFile)(unsafe.Pointer(&in.Items))
        out.DefaultMode = (*int32)(unsafe.Pointer(in.DefaultMode))
        return nil
}

// Convert_core_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource is an autogenerated conversion function.
func Convert_core_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in *core.DownwardAPIVolumeSource, out *corev1.DownwardAPIVolumeSource, s conversion.Scope) error {
        return autoConvert_core_DownwardAPIVolumeSource_To_v1_DownwardAPIVolumeSource(in, out, s)
}

func autoConvert_v1_EmptyDirVolumeSource_To_core_EmptyDirVolumeSource(in *corev1.EmptyDirVolumeSource, out *core.EmptyDirVolumeSource, s conversion.Scope) error {
        out.Medium = core.StorageMedium(in.Medium)
        out.SizeLimit = (*resource.Quantity)(unsafe.Pointer(in.SizeLimit))
        return nil
}

// Convert_v1_EmptyDirVolumeSource_To_core_EmptyDirVolumeSource is an autogenerated conversion function.
func Convert_v1_EmptyDirVolumeSource_To_core_EmptyDirVolumeSource(in *corev1.EmptyDirVolumeSource, out *core.EmptyDirVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_EmptyDirVolumeSource_To_core_EmptyDirVolumeSource(in, out, s)
}

func autoConvert_core_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *core.EmptyDirVolumeSource, out *corev1.EmptyDirVolumeSource, s conversion.Scope) error {
        out.Medium = corev1.StorageMedium(in.Medium)
        out.SizeLimit = (*resource.Quantity)(unsafe.Pointer(in.SizeLimit))
        return nil
}

// Convert_core_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource is an autogenerated conversion function.
func Convert_core_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in *core.EmptyDirVolumeSource, out *corev1.EmptyDirVolumeSource, s conversion.Scope) error {
        return autoConvert_core_EmptyDirVolumeSource_To_v1_EmptyDirVolumeSource(in, out, s)
}

func autoConvert_v1_EndpointAddress_To_core_EndpointAddress(in *corev1.EndpointAddress, out *core.EndpointAddress, s conversion.Scope) error {
        out.IP = in.IP
        out.Hostname = in.Hostname
        out.NodeName = (*string)(unsafe.Pointer(in.NodeName))
        out.TargetRef = (*core.ObjectReference)(unsafe.Pointer(in.TargetRef))
        return nil
}

// Convert_v1_EndpointAddress_To_core_EndpointAddress is an autogenerated conversion function.
func Convert_v1_EndpointAddress_To_core_EndpointAddress(in *corev1.EndpointAddress, out *core.EndpointAddress, s conversion.Scope) error {
        return autoConvert_v1_EndpointAddress_To_core_EndpointAddress(in, out, s)
}

func autoConvert_core_EndpointAddress_To_v1_EndpointAddress(in *core.EndpointAddress, out *corev1.EndpointAddress, s conversion.Scope) error {
        out.IP = in.IP
        out.Hostname = in.Hostname
        out.NodeName = (*string)(unsafe.Pointer(in.NodeName))
        out.TargetRef = (*corev1.ObjectReference)(unsafe.Pointer(in.TargetRef))
        return nil
}

// Convert_core_EndpointAddress_To_v1_EndpointAddress is an autogenerated conversion function.
func Convert_core_EndpointAddress_To_v1_EndpointAddress(in *core.EndpointAddress, out *corev1.EndpointAddress, s conversion.Scope) error {
        return autoConvert_core_EndpointAddress_To_v1_EndpointAddress(in, out, s)
}

func autoConvert_v1_EndpointPort_To_core_EndpointPort(in *corev1.EndpointPort, out *core.EndpointPort, s conversion.Scope) error {
        out.Name = in.Name
        out.Port = in.Port
        out.Protocol = core.Protocol(in.Protocol)
        out.AppProtocol = (*string)(unsafe.Pointer(in.AppProtocol))
        return nil
}

// Convert_v1_EndpointPort_To_core_EndpointPort is an autogenerated conversion function.
func Convert_v1_EndpointPort_To_core_EndpointPort(in *corev1.EndpointPort, out *core.EndpointPort, s conversion.Scope) error {
        return autoConvert_v1_EndpointPort_To_core_EndpointPort(in, out, s)
}

func autoConvert_core_EndpointPort_To_v1_EndpointPort(in *core.EndpointPort, out *corev1.EndpointPort, s conversion.Scope) error {
        out.Name = in.Name
        out.Port = in.Port
        out.Protocol = corev1.Protocol(in.Protocol)
        out.AppProtocol = (*string)(unsafe.Pointer(in.AppProtocol))
        return nil
}

// Convert_core_EndpointPort_To_v1_EndpointPort is an autogenerated conversion function.
func Convert_core_EndpointPort_To_v1_EndpointPort(in *core.EndpointPort, out *corev1.EndpointPort, s conversion.Scope) error {
        return autoConvert_core_EndpointPort_To_v1_EndpointPort(in, out, s)
}

func autoConvert_v1_EndpointSubset_To_core_EndpointSubset(in *corev1.EndpointSubset, out *core.EndpointSubset, s conversion.Scope) error {
        out.Addresses = *(*[]core.EndpointAddress)(unsafe.Pointer(&in.Addresses))
        out.NotReadyAddresses = *(*[]core.EndpointAddress)(unsafe.Pointer(&in.NotReadyAddresses))
        out.Ports = *(*[]core.EndpointPort)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_v1_EndpointSubset_To_core_EndpointSubset is an autogenerated conversion function.
func Convert_v1_EndpointSubset_To_core_EndpointSubset(in *corev1.EndpointSubset, out *core.EndpointSubset, s conversion.Scope) error {
        return autoConvert_v1_EndpointSubset_To_core_EndpointSubset(in, out, s)
}

func autoConvert_core_EndpointSubset_To_v1_EndpointSubset(in *core.EndpointSubset, out *corev1.EndpointSubset, s conversion.Scope) error {
        out.Addresses = *(*[]corev1.EndpointAddress)(unsafe.Pointer(&in.Addresses))
        out.NotReadyAddresses = *(*[]corev1.EndpointAddress)(unsafe.Pointer(&in.NotReadyAddresses))
        out.Ports = *(*[]corev1.EndpointPort)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_core_EndpointSubset_To_v1_EndpointSubset is an autogenerated conversion function.
func Convert_core_EndpointSubset_To_v1_EndpointSubset(in *core.EndpointSubset, out *corev1.EndpointSubset, s conversion.Scope) error {
        return autoConvert_core_EndpointSubset_To_v1_EndpointSubset(in, out, s)
}

func autoConvert_v1_Endpoints_To_core_Endpoints(in *corev1.Endpoints, out *core.Endpoints, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Subsets = *(*[]core.EndpointSubset)(unsafe.Pointer(&in.Subsets))
        return nil
}

// Convert_v1_Endpoints_To_core_Endpoints is an autogenerated conversion function.
func Convert_v1_Endpoints_To_core_Endpoints(in *corev1.Endpoints, out *core.Endpoints, s conversion.Scope) error {
        return autoConvert_v1_Endpoints_To_core_Endpoints(in, out, s)
}

func autoConvert_core_Endpoints_To_v1_Endpoints(in *core.Endpoints, out *corev1.Endpoints, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Subsets = *(*[]corev1.EndpointSubset)(unsafe.Pointer(&in.Subsets))
        return nil
}

// Convert_core_Endpoints_To_v1_Endpoints is an autogenerated conversion function.
func Convert_core_Endpoints_To_v1_Endpoints(in *core.Endpoints, out *corev1.Endpoints, s conversion.Scope) error {
        return autoConvert_core_Endpoints_To_v1_Endpoints(in, out, s)
}

func autoConvert_v1_EndpointsList_To_core_EndpointsList(in *corev1.EndpointsList, out *core.EndpointsList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.Endpoints)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_EndpointsList_To_core_EndpointsList is an autogenerated conversion function.
func Convert_v1_EndpointsList_To_core_EndpointsList(in *corev1.EndpointsList, out *core.EndpointsList, s conversion.Scope) error {
        return autoConvert_v1_EndpointsList_To_core_EndpointsList(in, out, s)
}

func autoConvert_core_EndpointsList_To_v1_EndpointsList(in *core.EndpointsList, out *corev1.EndpointsList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.Endpoints)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_EndpointsList_To_v1_EndpointsList is an autogenerated conversion function.
func Convert_core_EndpointsList_To_v1_EndpointsList(in *core.EndpointsList, out *corev1.EndpointsList, s conversion.Scope) error {
        return autoConvert_core_EndpointsList_To_v1_EndpointsList(in, out, s)
}

func autoConvert_v1_EnvFromSource_To_core_EnvFromSource(in *corev1.EnvFromSource, out *core.EnvFromSource, s conversion.Scope) error {
        out.Prefix = in.Prefix
        out.ConfigMapRef = (*core.ConfigMapEnvSource)(unsafe.Pointer(in.ConfigMapRef))
        out.SecretRef = (*core.SecretEnvSource)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_v1_EnvFromSource_To_core_EnvFromSource is an autogenerated conversion function.
func Convert_v1_EnvFromSource_To_core_EnvFromSource(in *corev1.EnvFromSource, out *core.EnvFromSource, s conversion.Scope) error {
        return autoConvert_v1_EnvFromSource_To_core_EnvFromSource(in, out, s)
}

func autoConvert_core_EnvFromSource_To_v1_EnvFromSource(in *core.EnvFromSource, out *corev1.EnvFromSource, s conversion.Scope) error {
        out.Prefix = in.Prefix
        out.ConfigMapRef = (*corev1.ConfigMapEnvSource)(unsafe.Pointer(in.ConfigMapRef))
        out.SecretRef = (*corev1.SecretEnvSource)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_core_EnvFromSource_To_v1_EnvFromSource is an autogenerated conversion function.
func Convert_core_EnvFromSource_To_v1_EnvFromSource(in *core.EnvFromSource, out *corev1.EnvFromSource, s conversion.Scope) error {
        return autoConvert_core_EnvFromSource_To_v1_EnvFromSource(in, out, s)
}

func autoConvert_v1_EnvVar_To_core_EnvVar(in *corev1.EnvVar, out *core.EnvVar, s conversion.Scope) error {
        out.Name = in.Name
        out.Value = in.Value
        out.ValueFrom = (*core.EnvVarSource)(unsafe.Pointer(in.ValueFrom))
        return nil
}

// Convert_v1_EnvVar_To_core_EnvVar is an autogenerated conversion function.
func Convert_v1_EnvVar_To_core_EnvVar(in *corev1.EnvVar, out *core.EnvVar, s conversion.Scope) error {
        return autoConvert_v1_EnvVar_To_core_EnvVar(in, out, s)
}

func autoConvert_core_EnvVar_To_v1_EnvVar(in *core.EnvVar, out *corev1.EnvVar, s conversion.Scope) error {
        out.Name = in.Name
        out.Value = in.Value
        out.ValueFrom = (*corev1.EnvVarSource)(unsafe.Pointer(in.ValueFrom))
        return nil
}

// Convert_core_EnvVar_To_v1_EnvVar is an autogenerated conversion function.
func Convert_core_EnvVar_To_v1_EnvVar(in *core.EnvVar, out *corev1.EnvVar, s conversion.Scope) error {
        return autoConvert_core_EnvVar_To_v1_EnvVar(in, out, s)
}

func autoConvert_v1_EnvVarSource_To_core_EnvVarSource(in *corev1.EnvVarSource, out *core.EnvVarSource, s conversion.Scope) error {
        out.FieldRef = (*core.ObjectFieldSelector)(unsafe.Pointer(in.FieldRef))
        out.ResourceFieldRef = (*core.ResourceFieldSelector)(unsafe.Pointer(in.ResourceFieldRef))
        out.ConfigMapKeyRef = (*core.ConfigMapKeySelector)(unsafe.Pointer(in.ConfigMapKeyRef))
        out.SecretKeyRef = (*core.SecretKeySelector)(unsafe.Pointer(in.SecretKeyRef))
        out.FileKeyRef = (*core.FileKeySelector)(unsafe.Pointer(in.FileKeyRef))
        return nil
}

// Convert_v1_EnvVarSource_To_core_EnvVarSource is an autogenerated conversion function.
func Convert_v1_EnvVarSource_To_core_EnvVarSource(in *corev1.EnvVarSource, out *core.EnvVarSource, s conversion.Scope) error {
        return autoConvert_v1_EnvVarSource_To_core_EnvVarSource(in, out, s)
}

func autoConvert_core_EnvVarSource_To_v1_EnvVarSource(in *core.EnvVarSource, out *corev1.EnvVarSource, s conversion.Scope) error {
        out.FieldRef = (*corev1.ObjectFieldSelector)(unsafe.Pointer(in.FieldRef))
        out.ResourceFieldRef = (*corev1.ResourceFieldSelector)(unsafe.Pointer(in.ResourceFieldRef))
        out.ConfigMapKeyRef = (*corev1.ConfigMapKeySelector)(unsafe.Pointer(in.ConfigMapKeyRef))
        out.SecretKeyRef = (*corev1.SecretKeySelector)(unsafe.Pointer(in.SecretKeyRef))
        out.FileKeyRef = (*corev1.FileKeySelector)(unsafe.Pointer(in.FileKeyRef))
        return nil
}

// Convert_core_EnvVarSource_To_v1_EnvVarSource is an autogenerated conversion function.
func Convert_core_EnvVarSource_To_v1_EnvVarSource(in *core.EnvVarSource, out *corev1.EnvVarSource, s conversion.Scope) error {
        return autoConvert_core_EnvVarSource_To_v1_EnvVarSource(in, out, s)
}

func autoConvert_v1_EphemeralContainer_To_core_EphemeralContainer(in *corev1.EphemeralContainer, out *core.EphemeralContainer, s conversion.Scope) error {
        if err := Convert_v1_EphemeralContainerCommon_To_core_EphemeralContainerCommon(&in.EphemeralContainerCommon, &out.EphemeralContainerCommon, s); err != nil {
                return err
        }
        out.TargetContainerName = in.TargetContainerName
        return nil
}

// Convert_v1_EphemeralContainer_To_core_EphemeralContainer is an autogenerated conversion function.
func Convert_v1_EphemeralContainer_To_core_EphemeralContainer(in *corev1.EphemeralContainer, out *core.EphemeralContainer, s conversion.Scope) error {
        return autoConvert_v1_EphemeralContainer_To_core_EphemeralContainer(in, out, s)
}

func autoConvert_core_EphemeralContainer_To_v1_EphemeralContainer(in *core.EphemeralContainer, out *corev1.EphemeralContainer, s conversion.Scope) error {
        if err := Convert_core_EphemeralContainerCommon_To_v1_EphemeralContainerCommon(&in.EphemeralContainerCommon, &out.EphemeralContainerCommon, s); err != nil {
                return err
        }
        out.TargetContainerName = in.TargetContainerName
        return nil
}

// Convert_core_EphemeralContainer_To_v1_EphemeralContainer is an autogenerated conversion function.
func Convert_core_EphemeralContainer_To_v1_EphemeralContainer(in *core.EphemeralContainer, out *corev1.EphemeralContainer, s conversion.Scope) error {
        return autoConvert_core_EphemeralContainer_To_v1_EphemeralContainer(in, out, s)
}

func autoConvert_v1_EphemeralContainerCommon_To_core_EphemeralContainerCommon(in *corev1.EphemeralContainerCommon, out *core.EphemeralContainerCommon, s conversion.Scope) error {
        out.Name = in.Name
        out.Image = in.Image
        out.Command = *(*[]string)(unsafe.Pointer(&in.Command))
        out.Args = *(*[]string)(unsafe.Pointer(&in.Args))
        out.WorkingDir = in.WorkingDir
        out.Ports = *(*[]core.ContainerPort)(unsafe.Pointer(&in.Ports))
        out.EnvFrom = *(*[]core.EnvFromSource)(unsafe.Pointer(&in.EnvFrom))
        out.Env = *(*[]core.EnvVar)(unsafe.Pointer(&in.Env))
        if err := Convert_v1_ResourceRequirements_To_core_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
                return err
        }
        out.ResizePolicy = *(*[]core.ContainerResizePolicy)(unsafe.Pointer(&in.ResizePolicy))
        out.RestartPolicy = (*core.ContainerRestartPolicy)(unsafe.Pointer(in.RestartPolicy))
        out.RestartPolicyRules = *(*[]core.ContainerRestartRule)(unsafe.Pointer(&in.RestartPolicyRules))
        out.VolumeMounts = *(*[]core.VolumeMount)(unsafe.Pointer(&in.VolumeMounts))
        out.VolumeDevices = *(*[]core.VolumeDevice)(unsafe.Pointer(&in.VolumeDevices))
        out.LivenessProbe = (*core.Probe)(unsafe.Pointer(in.LivenessProbe))
        out.ReadinessProbe = (*core.Probe)(unsafe.Pointer(in.ReadinessProbe))
        out.StartupProbe = (*core.Probe)(unsafe.Pointer(in.StartupProbe))
        out.Lifecycle = (*core.Lifecycle)(unsafe.Pointer(in.Lifecycle))
        out.TerminationMessagePath = in.TerminationMessagePath
        out.TerminationMessagePolicy = core.TerminationMessagePolicy(in.TerminationMessagePolicy)
        out.ImagePullPolicy = core.PullPolicy(in.ImagePullPolicy)
        out.SecurityContext = (*core.SecurityContext)(unsafe.Pointer(in.SecurityContext))
        out.Stdin = in.Stdin
        out.StdinOnce = in.StdinOnce
        out.TTY = in.TTY
        return nil
}

// Convert_v1_EphemeralContainerCommon_To_core_EphemeralContainerCommon is an autogenerated conversion function.
func Convert_v1_EphemeralContainerCommon_To_core_EphemeralContainerCommon(in *corev1.EphemeralContainerCommon, out *core.EphemeralContainerCommon, s conversion.Scope) error {
        return autoConvert_v1_EphemeralContainerCommon_To_core_EphemeralContainerCommon(in, out, s)
}

func autoConvert_core_EphemeralContainerCommon_To_v1_EphemeralContainerCommon(in *core.EphemeralContainerCommon, out *corev1.EphemeralContainerCommon, s conversion.Scope) error {
        out.Name = in.Name
        out.Image = in.Image
        out.Command = *(*[]string)(unsafe.Pointer(&in.Command))
        out.Args = *(*[]string)(unsafe.Pointer(&in.Args))
        out.WorkingDir = in.WorkingDir
        out.Ports = *(*[]corev1.ContainerPort)(unsafe.Pointer(&in.Ports))
        out.EnvFrom = *(*[]corev1.EnvFromSource)(unsafe.Pointer(&in.EnvFrom))
        out.Env = *(*[]corev1.EnvVar)(unsafe.Pointer(&in.Env))
        if err := Convert_core_ResourceRequirements_To_v1_ResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
                return err
        }
        out.ResizePolicy = *(*[]corev1.ContainerResizePolicy)(unsafe.Pointer(&in.ResizePolicy))
        out.RestartPolicy = (*corev1.ContainerRestartPolicy)(unsafe.Pointer(in.RestartPolicy))
        out.RestartPolicyRules = *(*[]corev1.ContainerRestartRule)(unsafe.Pointer(&in.RestartPolicyRules))
        out.VolumeMounts = *(*[]corev1.VolumeMount)(unsafe.Pointer(&in.VolumeMounts))
        out.VolumeDevices = *(*[]corev1.VolumeDevice)(unsafe.Pointer(&in.VolumeDevices))
        out.LivenessProbe = (*corev1.Probe)(unsafe.Pointer(in.LivenessProbe))
        out.ReadinessProbe = (*corev1.Probe)(unsafe.Pointer(in.ReadinessProbe))
        out.StartupProbe = (*corev1.Probe)(unsafe.Pointer(in.StartupProbe))
        out.Lifecycle = (*corev1.Lifecycle)(unsafe.Pointer(in.Lifecycle))
        out.TerminationMessagePath = in.TerminationMessagePath
        out.TerminationMessagePolicy = corev1.TerminationMessagePolicy(in.TerminationMessagePolicy)
        out.ImagePullPolicy = corev1.PullPolicy(in.ImagePullPolicy)
        out.SecurityContext = (*corev1.SecurityContext)(unsafe.Pointer(in.SecurityContext))
        out.Stdin = in.Stdin
        out.StdinOnce = in.StdinOnce
        out.TTY = in.TTY
        return nil
}

// Convert_core_EphemeralContainerCommon_To_v1_EphemeralContainerCommon is an autogenerated conversion function.
func Convert_core_EphemeralContainerCommon_To_v1_EphemeralContainerCommon(in *core.EphemeralContainerCommon, out *corev1.EphemeralContainerCommon, s conversion.Scope) error {
        return autoConvert_core_EphemeralContainerCommon_To_v1_EphemeralContainerCommon(in, out, s)
}

func autoConvert_v1_EphemeralVolumeSource_To_core_EphemeralVolumeSource(in *corev1.EphemeralVolumeSource, out *core.EphemeralVolumeSource, s conversion.Scope) error {
        out.VolumeClaimTemplate = (*core.PersistentVolumeClaimTemplate)(unsafe.Pointer(in.VolumeClaimTemplate))
        return nil
}

// Convert_v1_EphemeralVolumeSource_To_core_EphemeralVolumeSource is an autogenerated conversion function.
func Convert_v1_EphemeralVolumeSource_To_core_EphemeralVolumeSource(in *corev1.EphemeralVolumeSource, out *core.EphemeralVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_EphemeralVolumeSource_To_core_EphemeralVolumeSource(in, out, s)
}

func autoConvert_core_EphemeralVolumeSource_To_v1_EphemeralVolumeSource(in *core.EphemeralVolumeSource, out *corev1.EphemeralVolumeSource, s conversion.Scope) error {
        out.VolumeClaimTemplate = (*corev1.PersistentVolumeClaimTemplate)(unsafe.Pointer(in.VolumeClaimTemplate))
        return nil
}

// Convert_core_EphemeralVolumeSource_To_v1_EphemeralVolumeSource is an autogenerated conversion function.
func Convert_core_EphemeralVolumeSource_To_v1_EphemeralVolumeSource(in *core.EphemeralVolumeSource, out *corev1.EphemeralVolumeSource, s conversion.Scope) error {
        return autoConvert_core_EphemeralVolumeSource_To_v1_EphemeralVolumeSource(in, out, s)
}

func autoConvert_v1_Event_To_core_Event(in *corev1.Event, out *core.Event, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ObjectReference_To_core_ObjectReference(&in.InvolvedObject, &out.InvolvedObject, s); err != nil {
                return err
        }
        out.Reason = in.Reason
        out.Message = in.Message
        if err := Convert_v1_EventSource_To_core_EventSource(&in.Source, &out.Source, s); err != nil {
                return err
        }
        out.FirstTimestamp = in.FirstTimestamp
        out.LastTimestamp = in.LastTimestamp
        out.Count = in.Count
        out.Type = in.Type
        out.EventTime = in.EventTime
        out.Series = (*core.EventSeries)(unsafe.Pointer(in.Series))
        out.Action = in.Action
        out.Related = (*core.ObjectReference)(unsafe.Pointer(in.Related))
        out.ReportingController = in.ReportingController
        out.ReportingInstance = in.ReportingInstance
        return nil
}

// Convert_v1_Event_To_core_Event is an autogenerated conversion function.
func Convert_v1_Event_To_core_Event(in *corev1.Event, out *core.Event, s conversion.Scope) error {
        return autoConvert_v1_Event_To_core_Event(in, out, s)
}

func autoConvert_core_Event_To_v1_Event(in *core.Event, out *corev1.Event, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_ObjectReference_To_v1_ObjectReference(&in.InvolvedObject, &out.InvolvedObject, s); err != nil {
                return err
        }
        out.Reason = in.Reason
        out.Message = in.Message
        if err := Convert_core_EventSource_To_v1_EventSource(&in.Source, &out.Source, s); err != nil {
                return err
        }
        out.FirstTimestamp = in.FirstTimestamp
        out.LastTimestamp = in.LastTimestamp
        out.Count = in.Count
        out.Type = in.Type
        out.EventTime = in.EventTime
        out.Series = (*corev1.EventSeries)(unsafe.Pointer(in.Series))
        out.Action = in.Action
        out.Related = (*corev1.ObjectReference)(unsafe.Pointer(in.Related))
        out.ReportingController = in.ReportingController
        out.ReportingInstance = in.ReportingInstance
        return nil
}

// Convert_core_Event_To_v1_Event is an autogenerated conversion function.
func Convert_core_Event_To_v1_Event(in *core.Event, out *corev1.Event, s conversion.Scope) error {
        return autoConvert_core_Event_To_v1_Event(in, out, s)
}

func autoConvert_v1_EventList_To_core_EventList(in *corev1.EventList, out *core.EventList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.Event)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_EventList_To_core_EventList is an autogenerated conversion function.
func Convert_v1_EventList_To_core_EventList(in *corev1.EventList, out *core.EventList, s conversion.Scope) error {
        return autoConvert_v1_EventList_To_core_EventList(in, out, s)
}

func autoConvert_core_EventList_To_v1_EventList(in *core.EventList, out *corev1.EventList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.Event)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_EventList_To_v1_EventList is an autogenerated conversion function.
func Convert_core_EventList_To_v1_EventList(in *core.EventList, out *corev1.EventList, s conversion.Scope) error {
        return autoConvert_core_EventList_To_v1_EventList(in, out, s)
}

func autoConvert_v1_EventSeries_To_core_EventSeries(in *corev1.EventSeries, out *core.EventSeries, s conversion.Scope) error {
        out.Count = in.Count
        out.LastObservedTime = in.LastObservedTime
        return nil
}

// Convert_v1_EventSeries_To_core_EventSeries is an autogenerated conversion function.
func Convert_v1_EventSeries_To_core_EventSeries(in *corev1.EventSeries, out *core.EventSeries, s conversion.Scope) error {
        return autoConvert_v1_EventSeries_To_core_EventSeries(in, out, s)
}

func autoConvert_core_EventSeries_To_v1_EventSeries(in *core.EventSeries, out *corev1.EventSeries, s conversion.Scope) error {
        out.Count = in.Count
        out.LastObservedTime = in.LastObservedTime
        return nil
}

// Convert_core_EventSeries_To_v1_EventSeries is an autogenerated conversion function.
func Convert_core_EventSeries_To_v1_EventSeries(in *core.EventSeries, out *corev1.EventSeries, s conversion.Scope) error {
        return autoConvert_core_EventSeries_To_v1_EventSeries(in, out, s)
}

func autoConvert_v1_EventSource_To_core_EventSource(in *corev1.EventSource, out *core.EventSource, s conversion.Scope) error {
        out.Component = in.Component
        out.Host = in.Host
        return nil
}

// Convert_v1_EventSource_To_core_EventSource is an autogenerated conversion function.
func Convert_v1_EventSource_To_core_EventSource(in *corev1.EventSource, out *core.EventSource, s conversion.Scope) error {
        return autoConvert_v1_EventSource_To_core_EventSource(in, out, s)
}

func autoConvert_core_EventSource_To_v1_EventSource(in *core.EventSource, out *corev1.EventSource, s conversion.Scope) error {
        out.Component = in.Component
        out.Host = in.Host
        return nil
}

// Convert_core_EventSource_To_v1_EventSource is an autogenerated conversion function.
func Convert_core_EventSource_To_v1_EventSource(in *core.EventSource, out *corev1.EventSource, s conversion.Scope) error {
        return autoConvert_core_EventSource_To_v1_EventSource(in, out, s)
}

func autoConvert_v1_ExecAction_To_core_ExecAction(in *corev1.ExecAction, out *core.ExecAction, s conversion.Scope) error {
        out.Command = *(*[]string)(unsafe.Pointer(&in.Command))
        return nil
}

// Convert_v1_ExecAction_To_core_ExecAction is an autogenerated conversion function.
func Convert_v1_ExecAction_To_core_ExecAction(in *corev1.ExecAction, out *core.ExecAction, s conversion.Scope) error {
        return autoConvert_v1_ExecAction_To_core_ExecAction(in, out, s)
}

func autoConvert_core_ExecAction_To_v1_ExecAction(in *core.ExecAction, out *corev1.ExecAction, s conversion.Scope) error {
        out.Command = *(*[]string)(unsafe.Pointer(&in.Command))
        return nil
}

// Convert_core_ExecAction_To_v1_ExecAction is an autogenerated conversion function.
func Convert_core_ExecAction_To_v1_ExecAction(in *core.ExecAction, out *corev1.ExecAction, s conversion.Scope) error {
        return autoConvert_core_ExecAction_To_v1_ExecAction(in, out, s)
}

func autoConvert_v1_FCVolumeSource_To_core_FCVolumeSource(in *corev1.FCVolumeSource, out *core.FCVolumeSource, s conversion.Scope) error {
        out.TargetWWNs = *(*[]string)(unsafe.Pointer(&in.TargetWWNs))
        out.Lun = (*int32)(unsafe.Pointer(in.Lun))
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.WWIDs = *(*[]string)(unsafe.Pointer(&in.WWIDs))
        return nil
}

// Convert_v1_FCVolumeSource_To_core_FCVolumeSource is an autogenerated conversion function.
func Convert_v1_FCVolumeSource_To_core_FCVolumeSource(in *corev1.FCVolumeSource, out *core.FCVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_FCVolumeSource_To_core_FCVolumeSource(in, out, s)
}

func autoConvert_core_FCVolumeSource_To_v1_FCVolumeSource(in *core.FCVolumeSource, out *corev1.FCVolumeSource, s conversion.Scope) error {
        out.TargetWWNs = *(*[]string)(unsafe.Pointer(&in.TargetWWNs))
        out.Lun = (*int32)(unsafe.Pointer(in.Lun))
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.WWIDs = *(*[]string)(unsafe.Pointer(&in.WWIDs))
        return nil
}

// Convert_core_FCVolumeSource_To_v1_FCVolumeSource is an autogenerated conversion function.
func Convert_core_FCVolumeSource_To_v1_FCVolumeSource(in *core.FCVolumeSource, out *corev1.FCVolumeSource, s conversion.Scope) error {
        return autoConvert_core_FCVolumeSource_To_v1_FCVolumeSource(in, out, s)
}

func autoConvert_v1_FileKeySelector_To_core_FileKeySelector(in *corev1.FileKeySelector, out *core.FileKeySelector, s conversion.Scope) error {
        out.VolumeName = in.VolumeName
        out.Path = in.Path
        out.Key = in.Key
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_FileKeySelector_To_core_FileKeySelector is an autogenerated conversion function.
func Convert_v1_FileKeySelector_To_core_FileKeySelector(in *corev1.FileKeySelector, out *core.FileKeySelector, s conversion.Scope) error {
        return autoConvert_v1_FileKeySelector_To_core_FileKeySelector(in, out, s)
}

func autoConvert_core_FileKeySelector_To_v1_FileKeySelector(in *core.FileKeySelector, out *corev1.FileKeySelector, s conversion.Scope) error {
        out.VolumeName = in.VolumeName
        out.Path = in.Path
        out.Key = in.Key
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_FileKeySelector_To_v1_FileKeySelector is an autogenerated conversion function.
func Convert_core_FileKeySelector_To_v1_FileKeySelector(in *core.FileKeySelector, out *corev1.FileKeySelector, s conversion.Scope) error {
        return autoConvert_core_FileKeySelector_To_v1_FileKeySelector(in, out, s)
}

func autoConvert_v1_FlexPersistentVolumeSource_To_core_FlexPersistentVolumeSource(in *corev1.FlexPersistentVolumeSource, out *core.FlexPersistentVolumeSource, s conversion.Scope) error {
        out.Driver = in.Driver
        out.FSType = in.FSType
        out.SecretRef = (*core.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        out.Options = *(*map[string]string)(unsafe.Pointer(&in.Options))
        return nil
}

// Convert_v1_FlexPersistentVolumeSource_To_core_FlexPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_FlexPersistentVolumeSource_To_core_FlexPersistentVolumeSource(in *corev1.FlexPersistentVolumeSource, out *core.FlexPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_FlexPersistentVolumeSource_To_core_FlexPersistentVolumeSource(in, out, s)
}

func autoConvert_core_FlexPersistentVolumeSource_To_v1_FlexPersistentVolumeSource(in *core.FlexPersistentVolumeSource, out *corev1.FlexPersistentVolumeSource, s conversion.Scope) error {
        out.Driver = in.Driver
        out.FSType = in.FSType
        out.SecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        out.Options = *(*map[string]string)(unsafe.Pointer(&in.Options))
        return nil
}

// Convert_core_FlexPersistentVolumeSource_To_v1_FlexPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_FlexPersistentVolumeSource_To_v1_FlexPersistentVolumeSource(in *core.FlexPersistentVolumeSource, out *corev1.FlexPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_FlexPersistentVolumeSource_To_v1_FlexPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_FlexVolumeSource_To_core_FlexVolumeSource(in *corev1.FlexVolumeSource, out *core.FlexVolumeSource, s conversion.Scope) error {
        out.Driver = in.Driver
        out.FSType = in.FSType
        out.SecretRef = (*core.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        out.Options = *(*map[string]string)(unsafe.Pointer(&in.Options))
        return nil
}

// Convert_v1_FlexVolumeSource_To_core_FlexVolumeSource is an autogenerated conversion function.
func Convert_v1_FlexVolumeSource_To_core_FlexVolumeSource(in *corev1.FlexVolumeSource, out *core.FlexVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_FlexVolumeSource_To_core_FlexVolumeSource(in, out, s)
}

func autoConvert_core_FlexVolumeSource_To_v1_FlexVolumeSource(in *core.FlexVolumeSource, out *corev1.FlexVolumeSource, s conversion.Scope) error {
        out.Driver = in.Driver
        out.FSType = in.FSType
        out.SecretRef = (*corev1.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        out.Options = *(*map[string]string)(unsafe.Pointer(&in.Options))
        return nil
}

// Convert_core_FlexVolumeSource_To_v1_FlexVolumeSource is an autogenerated conversion function.
func Convert_core_FlexVolumeSource_To_v1_FlexVolumeSource(in *core.FlexVolumeSource, out *corev1.FlexVolumeSource, s conversion.Scope) error {
        return autoConvert_core_FlexVolumeSource_To_v1_FlexVolumeSource(in, out, s)
}

func autoConvert_v1_FlockerVolumeSource_To_core_FlockerVolumeSource(in *corev1.FlockerVolumeSource, out *core.FlockerVolumeSource, s conversion.Scope) error {
        out.DatasetName = in.DatasetName
        out.DatasetUUID = in.DatasetUUID
        return nil
}

// Convert_v1_FlockerVolumeSource_To_core_FlockerVolumeSource is an autogenerated conversion function.
func Convert_v1_FlockerVolumeSource_To_core_FlockerVolumeSource(in *corev1.FlockerVolumeSource, out *core.FlockerVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_FlockerVolumeSource_To_core_FlockerVolumeSource(in, out, s)
}

func autoConvert_core_FlockerVolumeSource_To_v1_FlockerVolumeSource(in *core.FlockerVolumeSource, out *corev1.FlockerVolumeSource, s conversion.Scope) error {
        out.DatasetName = in.DatasetName
        out.DatasetUUID = in.DatasetUUID
        return nil
}

// Convert_core_FlockerVolumeSource_To_v1_FlockerVolumeSource is an autogenerated conversion function.
func Convert_core_FlockerVolumeSource_To_v1_FlockerVolumeSource(in *core.FlockerVolumeSource, out *corev1.FlockerVolumeSource, s conversion.Scope) error {
        return autoConvert_core_FlockerVolumeSource_To_v1_FlockerVolumeSource(in, out, s)
}

func autoConvert_v1_GCEPersistentDiskVolumeSource_To_core_GCEPersistentDiskVolumeSource(in *corev1.GCEPersistentDiskVolumeSource, out *core.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
        out.PDName = in.PDName
        out.FSType = in.FSType
        out.Partition = in.Partition
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_GCEPersistentDiskVolumeSource_To_core_GCEPersistentDiskVolumeSource is an autogenerated conversion function.
func Convert_v1_GCEPersistentDiskVolumeSource_To_core_GCEPersistentDiskVolumeSource(in *corev1.GCEPersistentDiskVolumeSource, out *core.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_GCEPersistentDiskVolumeSource_To_core_GCEPersistentDiskVolumeSource(in, out, s)
}

func autoConvert_core_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in *core.GCEPersistentDiskVolumeSource, out *corev1.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
        out.PDName = in.PDName
        out.FSType = in.FSType
        out.Partition = in.Partition
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource is an autogenerated conversion function.
func Convert_core_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in *core.GCEPersistentDiskVolumeSource, out *corev1.GCEPersistentDiskVolumeSource, s conversion.Scope) error {
        return autoConvert_core_GCEPersistentDiskVolumeSource_To_v1_GCEPersistentDiskVolumeSource(in, out, s)
}

func autoConvert_v1_GRPCAction_To_core_GRPCAction(in *corev1.GRPCAction, out *core.GRPCAction, s conversion.Scope) error {
        out.Port = in.Port
        out.Service = (*string)(unsafe.Pointer(in.Service))
        return nil
}

// Convert_v1_GRPCAction_To_core_GRPCAction is an autogenerated conversion function.
func Convert_v1_GRPCAction_To_core_GRPCAction(in *corev1.GRPCAction, out *core.GRPCAction, s conversion.Scope) error {
        return autoConvert_v1_GRPCAction_To_core_GRPCAction(in, out, s)
}

func autoConvert_core_GRPCAction_To_v1_GRPCAction(in *core.GRPCAction, out *corev1.GRPCAction, s conversion.Scope) error {
        out.Port = in.Port
        out.Service = (*string)(unsafe.Pointer(in.Service))
        return nil
}

// Convert_core_GRPCAction_To_v1_GRPCAction is an autogenerated conversion function.
func Convert_core_GRPCAction_To_v1_GRPCAction(in *core.GRPCAction, out *corev1.GRPCAction, s conversion.Scope) error {
        return autoConvert_core_GRPCAction_To_v1_GRPCAction(in, out, s)
}

func autoConvert_v1_GitRepoVolumeSource_To_core_GitRepoVolumeSource(in *corev1.GitRepoVolumeSource, out *core.GitRepoVolumeSource, s conversion.Scope) error {
        out.Repository = in.Repository
        out.Revision = in.Revision
        out.Directory = in.Directory
        return nil
}

// Convert_v1_GitRepoVolumeSource_To_core_GitRepoVolumeSource is an autogenerated conversion function.
func Convert_v1_GitRepoVolumeSource_To_core_GitRepoVolumeSource(in *corev1.GitRepoVolumeSource, out *core.GitRepoVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_GitRepoVolumeSource_To_core_GitRepoVolumeSource(in, out, s)
}

func autoConvert_core_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in *core.GitRepoVolumeSource, out *corev1.GitRepoVolumeSource, s conversion.Scope) error {
        out.Repository = in.Repository
        out.Revision = in.Revision
        out.Directory = in.Directory
        return nil
}

// Convert_core_GitRepoVolumeSource_To_v1_GitRepoVolumeSource is an autogenerated conversion function.
func Convert_core_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in *core.GitRepoVolumeSource, out *corev1.GitRepoVolumeSource, s conversion.Scope) error {
        return autoConvert_core_GitRepoVolumeSource_To_v1_GitRepoVolumeSource(in, out, s)
}

func autoConvert_v1_GlusterfsPersistentVolumeSource_To_core_GlusterfsPersistentVolumeSource(in *corev1.GlusterfsPersistentVolumeSource, out *core.GlusterfsPersistentVolumeSource, s conversion.Scope) error {
        out.EndpointsName = in.EndpointsName
        out.Path = in.Path
        out.ReadOnly = in.ReadOnly
        out.EndpointsNamespace = (*string)(unsafe.Pointer(in.EndpointsNamespace))
        return nil
}

// Convert_v1_GlusterfsPersistentVolumeSource_To_core_GlusterfsPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_GlusterfsPersistentVolumeSource_To_core_GlusterfsPersistentVolumeSource(in *corev1.GlusterfsPersistentVolumeSource, out *core.GlusterfsPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_GlusterfsPersistentVolumeSource_To_core_GlusterfsPersistentVolumeSource(in, out, s)
}

func autoConvert_core_GlusterfsPersistentVolumeSource_To_v1_GlusterfsPersistentVolumeSource(in *core.GlusterfsPersistentVolumeSource, out *corev1.GlusterfsPersistentVolumeSource, s conversion.Scope) error {
        out.EndpointsName = in.EndpointsName
        out.Path = in.Path
        out.ReadOnly = in.ReadOnly
        out.EndpointsNamespace = (*string)(unsafe.Pointer(in.EndpointsNamespace))
        return nil
}

// Convert_core_GlusterfsPersistentVolumeSource_To_v1_GlusterfsPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_GlusterfsPersistentVolumeSource_To_v1_GlusterfsPersistentVolumeSource(in *core.GlusterfsPersistentVolumeSource, out *corev1.GlusterfsPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_GlusterfsPersistentVolumeSource_To_v1_GlusterfsPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_GlusterfsVolumeSource_To_core_GlusterfsVolumeSource(in *corev1.GlusterfsVolumeSource, out *core.GlusterfsVolumeSource, s conversion.Scope) error {
        out.EndpointsName = in.EndpointsName
        out.Path = in.Path
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_GlusterfsVolumeSource_To_core_GlusterfsVolumeSource is an autogenerated conversion function.
func Convert_v1_GlusterfsVolumeSource_To_core_GlusterfsVolumeSource(in *corev1.GlusterfsVolumeSource, out *core.GlusterfsVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_GlusterfsVolumeSource_To_core_GlusterfsVolumeSource(in, out, s)
}

func autoConvert_core_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in *core.GlusterfsVolumeSource, out *corev1.GlusterfsVolumeSource, s conversion.Scope) error {
        out.EndpointsName = in.EndpointsName
        out.Path = in.Path
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource is an autogenerated conversion function.
func Convert_core_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in *core.GlusterfsVolumeSource, out *corev1.GlusterfsVolumeSource, s conversion.Scope) error {
        return autoConvert_core_GlusterfsVolumeSource_To_v1_GlusterfsVolumeSource(in, out, s)
}

func autoConvert_v1_HTTPGetAction_To_core_HTTPGetAction(in *corev1.HTTPGetAction, out *core.HTTPGetAction, s conversion.Scope) error {
        out.Path = in.Path
        out.Port = in.Port
        out.Host = in.Host
        out.Scheme = core.URIScheme(in.Scheme)
        out.HTTPHeaders = *(*[]core.HTTPHeader)(unsafe.Pointer(&in.HTTPHeaders))
        return nil
}

// Convert_v1_HTTPGetAction_To_core_HTTPGetAction is an autogenerated conversion function.
func Convert_v1_HTTPGetAction_To_core_HTTPGetAction(in *corev1.HTTPGetAction, out *core.HTTPGetAction, s conversion.Scope) error {
        return autoConvert_v1_HTTPGetAction_To_core_HTTPGetAction(in, out, s)
}

func autoConvert_core_HTTPGetAction_To_v1_HTTPGetAction(in *core.HTTPGetAction, out *corev1.HTTPGetAction, s conversion.Scope) error {
        out.Path = in.Path
        out.Port = in.Port
        out.Host = in.Host
        out.Scheme = corev1.URIScheme(in.Scheme)
        out.HTTPHeaders = *(*[]corev1.HTTPHeader)(unsafe.Pointer(&in.HTTPHeaders))
        return nil
}

// Convert_core_HTTPGetAction_To_v1_HTTPGetAction is an autogenerated conversion function.
func Convert_core_HTTPGetAction_To_v1_HTTPGetAction(in *core.HTTPGetAction, out *corev1.HTTPGetAction, s conversion.Scope) error {
        return autoConvert_core_HTTPGetAction_To_v1_HTTPGetAction(in, out, s)
}

func autoConvert_v1_HTTPHeader_To_core_HTTPHeader(in *corev1.HTTPHeader, out *core.HTTPHeader, s conversion.Scope) error {
        out.Name = in.Name
        out.Value = in.Value
        return nil
}

// Convert_v1_HTTPHeader_To_core_HTTPHeader is an autogenerated conversion function.
func Convert_v1_HTTPHeader_To_core_HTTPHeader(in *corev1.HTTPHeader, out *core.HTTPHeader, s conversion.Scope) error {
        return autoConvert_v1_HTTPHeader_To_core_HTTPHeader(in, out, s)
}

func autoConvert_core_HTTPHeader_To_v1_HTTPHeader(in *core.HTTPHeader, out *corev1.HTTPHeader, s conversion.Scope) error {
        out.Name = in.Name
        out.Value = in.Value
        return nil
}

// Convert_core_HTTPHeader_To_v1_HTTPHeader is an autogenerated conversion function.
func Convert_core_HTTPHeader_To_v1_HTTPHeader(in *core.HTTPHeader, out *corev1.HTTPHeader, s conversion.Scope) error {
        return autoConvert_core_HTTPHeader_To_v1_HTTPHeader(in, out, s)
}

func autoConvert_v1_HostAlias_To_core_HostAlias(in *corev1.HostAlias, out *core.HostAlias, s conversion.Scope) error {
        out.IP = in.IP
        out.Hostnames = *(*[]string)(unsafe.Pointer(&in.Hostnames))
        return nil
}

// Convert_v1_HostAlias_To_core_HostAlias is an autogenerated conversion function.
func Convert_v1_HostAlias_To_core_HostAlias(in *corev1.HostAlias, out *core.HostAlias, s conversion.Scope) error {
        return autoConvert_v1_HostAlias_To_core_HostAlias(in, out, s)
}

func autoConvert_core_HostAlias_To_v1_HostAlias(in *core.HostAlias, out *corev1.HostAlias, s conversion.Scope) error {
        out.IP = in.IP
        out.Hostnames = *(*[]string)(unsafe.Pointer(&in.Hostnames))
        return nil
}

// Convert_core_HostAlias_To_v1_HostAlias is an autogenerated conversion function.
func Convert_core_HostAlias_To_v1_HostAlias(in *core.HostAlias, out *corev1.HostAlias, s conversion.Scope) error {
        return autoConvert_core_HostAlias_To_v1_HostAlias(in, out, s)
}

func autoConvert_v1_HostIP_To_core_HostIP(in *corev1.HostIP, out *core.HostIP, s conversion.Scope) error {
        out.IP = in.IP
        return nil
}

// Convert_v1_HostIP_To_core_HostIP is an autogenerated conversion function.
func Convert_v1_HostIP_To_core_HostIP(in *corev1.HostIP, out *core.HostIP, s conversion.Scope) error {
        return autoConvert_v1_HostIP_To_core_HostIP(in, out, s)
}

func autoConvert_core_HostIP_To_v1_HostIP(in *core.HostIP, out *corev1.HostIP, s conversion.Scope) error {
        out.IP = in.IP
        return nil
}

// Convert_core_HostIP_To_v1_HostIP is an autogenerated conversion function.
func Convert_core_HostIP_To_v1_HostIP(in *core.HostIP, out *corev1.HostIP, s conversion.Scope) error {
        return autoConvert_core_HostIP_To_v1_HostIP(in, out, s)
}

func autoConvert_v1_HostPathVolumeSource_To_core_HostPathVolumeSource(in *corev1.HostPathVolumeSource, out *core.HostPathVolumeSource, s conversion.Scope) error {
        out.Path = in.Path
        out.Type = (*core.HostPathType)(unsafe.Pointer(in.Type))
        return nil
}

// Convert_v1_HostPathVolumeSource_To_core_HostPathVolumeSource is an autogenerated conversion function.
func Convert_v1_HostPathVolumeSource_To_core_HostPathVolumeSource(in *corev1.HostPathVolumeSource, out *core.HostPathVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_HostPathVolumeSource_To_core_HostPathVolumeSource(in, out, s)
}

func autoConvert_core_HostPathVolumeSource_To_v1_HostPathVolumeSource(in *core.HostPathVolumeSource, out *corev1.HostPathVolumeSource, s conversion.Scope) error {
        out.Path = in.Path
        out.Type = (*corev1.HostPathType)(unsafe.Pointer(in.Type))
        return nil
}

// Convert_core_HostPathVolumeSource_To_v1_HostPathVolumeSource is an autogenerated conversion function.
func Convert_core_HostPathVolumeSource_To_v1_HostPathVolumeSource(in *core.HostPathVolumeSource, out *corev1.HostPathVolumeSource, s conversion.Scope) error {
        return autoConvert_core_HostPathVolumeSource_To_v1_HostPathVolumeSource(in, out, s)
}

func autoConvert_v1_ISCSIPersistentVolumeSource_To_core_ISCSIPersistentVolumeSource(in *corev1.ISCSIPersistentVolumeSource, out *core.ISCSIPersistentVolumeSource, s conversion.Scope) error {
        out.TargetPortal = in.TargetPortal
        out.IQN = in.IQN
        out.Lun = in.Lun
        out.ISCSIInterface = in.ISCSIInterface
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.Portals = *(*[]string)(unsafe.Pointer(&in.Portals))
        out.DiscoveryCHAPAuth = in.DiscoveryCHAPAuth
        out.SessionCHAPAuth = in.SessionCHAPAuth
        out.SecretRef = (*core.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.InitiatorName = (*string)(unsafe.Pointer(in.InitiatorName))
        return nil
}

// Convert_v1_ISCSIPersistentVolumeSource_To_core_ISCSIPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_ISCSIPersistentVolumeSource_To_core_ISCSIPersistentVolumeSource(in *corev1.ISCSIPersistentVolumeSource, out *core.ISCSIPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_ISCSIPersistentVolumeSource_To_core_ISCSIPersistentVolumeSource(in, out, s)
}

func autoConvert_core_ISCSIPersistentVolumeSource_To_v1_ISCSIPersistentVolumeSource(in *core.ISCSIPersistentVolumeSource, out *corev1.ISCSIPersistentVolumeSource, s conversion.Scope) error {
        out.TargetPortal = in.TargetPortal
        out.IQN = in.IQN
        out.Lun = in.Lun
        out.ISCSIInterface = in.ISCSIInterface
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.Portals = *(*[]string)(unsafe.Pointer(&in.Portals))
        out.DiscoveryCHAPAuth = in.DiscoveryCHAPAuth
        out.SessionCHAPAuth = in.SessionCHAPAuth
        out.SecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.InitiatorName = (*string)(unsafe.Pointer(in.InitiatorName))
        return nil
}

// Convert_core_ISCSIPersistentVolumeSource_To_v1_ISCSIPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_ISCSIPersistentVolumeSource_To_v1_ISCSIPersistentVolumeSource(in *core.ISCSIPersistentVolumeSource, out *corev1.ISCSIPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_ISCSIPersistentVolumeSource_To_v1_ISCSIPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_ISCSIVolumeSource_To_core_ISCSIVolumeSource(in *corev1.ISCSIVolumeSource, out *core.ISCSIVolumeSource, s conversion.Scope) error {
        out.TargetPortal = in.TargetPortal
        out.IQN = in.IQN
        out.Lun = in.Lun
        out.ISCSIInterface = in.ISCSIInterface
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.Portals = *(*[]string)(unsafe.Pointer(&in.Portals))
        out.DiscoveryCHAPAuth = in.DiscoveryCHAPAuth
        out.SessionCHAPAuth = in.SessionCHAPAuth
        out.SecretRef = (*core.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.InitiatorName = (*string)(unsafe.Pointer(in.InitiatorName))
        return nil
}

// Convert_v1_ISCSIVolumeSource_To_core_ISCSIVolumeSource is an autogenerated conversion function.
func Convert_v1_ISCSIVolumeSource_To_core_ISCSIVolumeSource(in *corev1.ISCSIVolumeSource, out *core.ISCSIVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_ISCSIVolumeSource_To_core_ISCSIVolumeSource(in, out, s)
}

func autoConvert_core_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in *core.ISCSIVolumeSource, out *corev1.ISCSIVolumeSource, s conversion.Scope) error {
        out.TargetPortal = in.TargetPortal
        out.IQN = in.IQN
        out.Lun = in.Lun
        out.ISCSIInterface = in.ISCSIInterface
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.Portals = *(*[]string)(unsafe.Pointer(&in.Portals))
        out.DiscoveryCHAPAuth = in.DiscoveryCHAPAuth
        out.SessionCHAPAuth = in.SessionCHAPAuth
        out.SecretRef = (*corev1.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.InitiatorName = (*string)(unsafe.Pointer(in.InitiatorName))
        return nil
}

// Convert_core_ISCSIVolumeSource_To_v1_ISCSIVolumeSource is an autogenerated conversion function.
func Convert_core_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in *core.ISCSIVolumeSource, out *corev1.ISCSIVolumeSource, s conversion.Scope) error {
        return autoConvert_core_ISCSIVolumeSource_To_v1_ISCSIVolumeSource(in, out, s)
}

func autoConvert_v1_ImageVolumeSource_To_core_ImageVolumeSource(in *corev1.ImageVolumeSource, out *core.ImageVolumeSource, s conversion.Scope) error {
        out.Reference = in.Reference
        out.PullPolicy = core.PullPolicy(in.PullPolicy)
        return nil
}

// Convert_v1_ImageVolumeSource_To_core_ImageVolumeSource is an autogenerated conversion function.
func Convert_v1_ImageVolumeSource_To_core_ImageVolumeSource(in *corev1.ImageVolumeSource, out *core.ImageVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_ImageVolumeSource_To_core_ImageVolumeSource(in, out, s)
}

func autoConvert_core_ImageVolumeSource_To_v1_ImageVolumeSource(in *core.ImageVolumeSource, out *corev1.ImageVolumeSource, s conversion.Scope) error {
        out.Reference = in.Reference
        out.PullPolicy = corev1.PullPolicy(in.PullPolicy)
        return nil
}

// Convert_core_ImageVolumeSource_To_v1_ImageVolumeSource is an autogenerated conversion function.
func Convert_core_ImageVolumeSource_To_v1_ImageVolumeSource(in *core.ImageVolumeSource, out *corev1.ImageVolumeSource, s conversion.Scope) error {
        return autoConvert_core_ImageVolumeSource_To_v1_ImageVolumeSource(in, out, s)
}

func autoConvert_v1_KeyToPath_To_core_KeyToPath(in *corev1.KeyToPath, out *core.KeyToPath, s conversion.Scope) error {
        out.Key = in.Key
        out.Path = in.Path
        out.Mode = (*int32)(unsafe.Pointer(in.Mode))
        return nil
}

// Convert_v1_KeyToPath_To_core_KeyToPath is an autogenerated conversion function.
func Convert_v1_KeyToPath_To_core_KeyToPath(in *corev1.KeyToPath, out *core.KeyToPath, s conversion.Scope) error {
        return autoConvert_v1_KeyToPath_To_core_KeyToPath(in, out, s)
}

func autoConvert_core_KeyToPath_To_v1_KeyToPath(in *core.KeyToPath, out *corev1.KeyToPath, s conversion.Scope) error {
        out.Key = in.Key
        out.Path = in.Path
        out.Mode = (*int32)(unsafe.Pointer(in.Mode))
        return nil
}

// Convert_core_KeyToPath_To_v1_KeyToPath is an autogenerated conversion function.
func Convert_core_KeyToPath_To_v1_KeyToPath(in *core.KeyToPath, out *corev1.KeyToPath, s conversion.Scope) error {
        return autoConvert_core_KeyToPath_To_v1_KeyToPath(in, out, s)
}

func autoConvert_v1_Lifecycle_To_core_Lifecycle(in *corev1.Lifecycle, out *core.Lifecycle, s conversion.Scope) error {
        out.PostStart = (*core.LifecycleHandler)(unsafe.Pointer(in.PostStart))
        out.PreStop = (*core.LifecycleHandler)(unsafe.Pointer(in.PreStop))
        out.StopSignal = (*core.Signal)(unsafe.Pointer(in.StopSignal))
        return nil
}

// Convert_v1_Lifecycle_To_core_Lifecycle is an autogenerated conversion function.
func Convert_v1_Lifecycle_To_core_Lifecycle(in *corev1.Lifecycle, out *core.Lifecycle, s conversion.Scope) error {
        return autoConvert_v1_Lifecycle_To_core_Lifecycle(in, out, s)
}

func autoConvert_core_Lifecycle_To_v1_Lifecycle(in *core.Lifecycle, out *corev1.Lifecycle, s conversion.Scope) error {
        out.PostStart = (*corev1.LifecycleHandler)(unsafe.Pointer(in.PostStart))
        out.PreStop = (*corev1.LifecycleHandler)(unsafe.Pointer(in.PreStop))
        out.StopSignal = (*corev1.Signal)(unsafe.Pointer(in.StopSignal))
        return nil
}

// Convert_core_Lifecycle_To_v1_Lifecycle is an autogenerated conversion function.
func Convert_core_Lifecycle_To_v1_Lifecycle(in *core.Lifecycle, out *corev1.Lifecycle, s conversion.Scope) error {
        return autoConvert_core_Lifecycle_To_v1_Lifecycle(in, out, s)
}

func autoConvert_v1_LifecycleHandler_To_core_LifecycleHandler(in *corev1.LifecycleHandler, out *core.LifecycleHandler, s conversion.Scope) error {
        out.Exec = (*core.ExecAction)(unsafe.Pointer(in.Exec))
        out.HTTPGet = (*core.HTTPGetAction)(unsafe.Pointer(in.HTTPGet))
        out.TCPSocket = (*core.TCPSocketAction)(unsafe.Pointer(in.TCPSocket))
        out.Sleep = (*core.SleepAction)(unsafe.Pointer(in.Sleep))
        return nil
}

// Convert_v1_LifecycleHandler_To_core_LifecycleHandler is an autogenerated conversion function.
func Convert_v1_LifecycleHandler_To_core_LifecycleHandler(in *corev1.LifecycleHandler, out *core.LifecycleHandler, s conversion.Scope) error {
        return autoConvert_v1_LifecycleHandler_To_core_LifecycleHandler(in, out, s)
}

func autoConvert_core_LifecycleHandler_To_v1_LifecycleHandler(in *core.LifecycleHandler, out *corev1.LifecycleHandler, s conversion.Scope) error {
        out.Exec = (*corev1.ExecAction)(unsafe.Pointer(in.Exec))
        out.HTTPGet = (*corev1.HTTPGetAction)(unsafe.Pointer(in.HTTPGet))
        out.TCPSocket = (*corev1.TCPSocketAction)(unsafe.Pointer(in.TCPSocket))
        out.Sleep = (*corev1.SleepAction)(unsafe.Pointer(in.Sleep))
        return nil
}

// Convert_core_LifecycleHandler_To_v1_LifecycleHandler is an autogenerated conversion function.
func Convert_core_LifecycleHandler_To_v1_LifecycleHandler(in *core.LifecycleHandler, out *corev1.LifecycleHandler, s conversion.Scope) error {
        return autoConvert_core_LifecycleHandler_To_v1_LifecycleHandler(in, out, s)
}

func autoConvert_v1_LimitRange_To_core_LimitRange(in *corev1.LimitRange, out *core.LimitRange, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_LimitRangeSpec_To_core_LimitRangeSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_LimitRange_To_core_LimitRange is an autogenerated conversion function.
func Convert_v1_LimitRange_To_core_LimitRange(in *corev1.LimitRange, out *core.LimitRange, s conversion.Scope) error {
        return autoConvert_v1_LimitRange_To_core_LimitRange(in, out, s)
}

func autoConvert_core_LimitRange_To_v1_LimitRange(in *core.LimitRange, out *corev1.LimitRange, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_LimitRangeSpec_To_v1_LimitRangeSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_LimitRange_To_v1_LimitRange is an autogenerated conversion function.
func Convert_core_LimitRange_To_v1_LimitRange(in *core.LimitRange, out *corev1.LimitRange, s conversion.Scope) error {
        return autoConvert_core_LimitRange_To_v1_LimitRange(in, out, s)
}

func autoConvert_v1_LimitRangeItem_To_core_LimitRangeItem(in *corev1.LimitRangeItem, out *core.LimitRangeItem, s conversion.Scope) error {
        out.Type = core.LimitType(in.Type)
        out.Max = *(*core.ResourceList)(unsafe.Pointer(&in.Max))
        out.Min = *(*core.ResourceList)(unsafe.Pointer(&in.Min))
        out.Default = *(*core.ResourceList)(unsafe.Pointer(&in.Default))
        out.DefaultRequest = *(*core.ResourceList)(unsafe.Pointer(&in.DefaultRequest))
        out.MaxLimitRequestRatio = *(*core.ResourceList)(unsafe.Pointer(&in.MaxLimitRequestRatio))
        return nil
}

// Convert_v1_LimitRangeItem_To_core_LimitRangeItem is an autogenerated conversion function.
func Convert_v1_LimitRangeItem_To_core_LimitRangeItem(in *corev1.LimitRangeItem, out *core.LimitRangeItem, s conversion.Scope) error {
        return autoConvert_v1_LimitRangeItem_To_core_LimitRangeItem(in, out, s)
}

func autoConvert_core_LimitRangeItem_To_v1_LimitRangeItem(in *core.LimitRangeItem, out *corev1.LimitRangeItem, s conversion.Scope) error {
        out.Type = corev1.LimitType(in.Type)
        out.Max = *(*corev1.ResourceList)(unsafe.Pointer(&in.Max))
        out.Min = *(*corev1.ResourceList)(unsafe.Pointer(&in.Min))
        out.Default = *(*corev1.ResourceList)(unsafe.Pointer(&in.Default))
        out.DefaultRequest = *(*corev1.ResourceList)(unsafe.Pointer(&in.DefaultRequest))
        out.MaxLimitRequestRatio = *(*corev1.ResourceList)(unsafe.Pointer(&in.MaxLimitRequestRatio))
        return nil
}

// Convert_core_LimitRangeItem_To_v1_LimitRangeItem is an autogenerated conversion function.
func Convert_core_LimitRangeItem_To_v1_LimitRangeItem(in *core.LimitRangeItem, out *corev1.LimitRangeItem, s conversion.Scope) error {
        return autoConvert_core_LimitRangeItem_To_v1_LimitRangeItem(in, out, s)
}

func autoConvert_v1_LimitRangeList_To_core_LimitRangeList(in *corev1.LimitRangeList, out *core.LimitRangeList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.LimitRange)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_LimitRangeList_To_core_LimitRangeList is an autogenerated conversion function.
func Convert_v1_LimitRangeList_To_core_LimitRangeList(in *corev1.LimitRangeList, out *core.LimitRangeList, s conversion.Scope) error {
        return autoConvert_v1_LimitRangeList_To_core_LimitRangeList(in, out, s)
}

func autoConvert_core_LimitRangeList_To_v1_LimitRangeList(in *core.LimitRangeList, out *corev1.LimitRangeList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.LimitRange)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_LimitRangeList_To_v1_LimitRangeList is an autogenerated conversion function.
func Convert_core_LimitRangeList_To_v1_LimitRangeList(in *core.LimitRangeList, out *corev1.LimitRangeList, s conversion.Scope) error {
        return autoConvert_core_LimitRangeList_To_v1_LimitRangeList(in, out, s)
}

func autoConvert_v1_LimitRangeSpec_To_core_LimitRangeSpec(in *corev1.LimitRangeSpec, out *core.LimitRangeSpec, s conversion.Scope) error {
        out.Limits = *(*[]core.LimitRangeItem)(unsafe.Pointer(&in.Limits))
        return nil
}

// Convert_v1_LimitRangeSpec_To_core_LimitRangeSpec is an autogenerated conversion function.
func Convert_v1_LimitRangeSpec_To_core_LimitRangeSpec(in *corev1.LimitRangeSpec, out *core.LimitRangeSpec, s conversion.Scope) error {
        return autoConvert_v1_LimitRangeSpec_To_core_LimitRangeSpec(in, out, s)
}

func autoConvert_core_LimitRangeSpec_To_v1_LimitRangeSpec(in *core.LimitRangeSpec, out *corev1.LimitRangeSpec, s conversion.Scope) error {
        out.Limits = *(*[]corev1.LimitRangeItem)(unsafe.Pointer(&in.Limits))
        return nil
}

// Convert_core_LimitRangeSpec_To_v1_LimitRangeSpec is an autogenerated conversion function.
func Convert_core_LimitRangeSpec_To_v1_LimitRangeSpec(in *core.LimitRangeSpec, out *corev1.LimitRangeSpec, s conversion.Scope) error {
        return autoConvert_core_LimitRangeSpec_To_v1_LimitRangeSpec(in, out, s)
}

func autoConvert_v1_LinuxContainerUser_To_core_LinuxContainerUser(in *corev1.LinuxContainerUser, out *core.LinuxContainerUser, s conversion.Scope) error {
        out.UID = in.UID
        out.GID = in.GID
        out.SupplementalGroups = *(*[]int64)(unsafe.Pointer(&in.SupplementalGroups))
        return nil
}

// Convert_v1_LinuxContainerUser_To_core_LinuxContainerUser is an autogenerated conversion function.
func Convert_v1_LinuxContainerUser_To_core_LinuxContainerUser(in *corev1.LinuxContainerUser, out *core.LinuxContainerUser, s conversion.Scope) error {
        return autoConvert_v1_LinuxContainerUser_To_core_LinuxContainerUser(in, out, s)
}

func autoConvert_core_LinuxContainerUser_To_v1_LinuxContainerUser(in *core.LinuxContainerUser, out *corev1.LinuxContainerUser, s conversion.Scope) error {
        out.UID = in.UID
        out.GID = in.GID
        out.SupplementalGroups = *(*[]int64)(unsafe.Pointer(&in.SupplementalGroups))
        return nil
}

// Convert_core_LinuxContainerUser_To_v1_LinuxContainerUser is an autogenerated conversion function.
func Convert_core_LinuxContainerUser_To_v1_LinuxContainerUser(in *core.LinuxContainerUser, out *corev1.LinuxContainerUser, s conversion.Scope) error {
        return autoConvert_core_LinuxContainerUser_To_v1_LinuxContainerUser(in, out, s)
}

func autoConvert_v1_List_To_core_List(in *corev1.List, out *core.List, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]runtime.Object, len(*in))
                for i := range *in {
                        if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_List_To_core_List is an autogenerated conversion function.
func Convert_v1_List_To_core_List(in *corev1.List, out *core.List, s conversion.Scope) error {
        return autoConvert_v1_List_To_core_List(in, out, s)
}

func autoConvert_core_List_To_v1_List(in *core.List, out *corev1.List, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]runtime.RawExtension, len(*in))
                for i := range *in {
                        if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_List_To_v1_List is an autogenerated conversion function.
func Convert_core_List_To_v1_List(in *core.List, out *corev1.List, s conversion.Scope) error {
        return autoConvert_core_List_To_v1_List(in, out, s)
}

func autoConvert_v1_LoadBalancerIngress_To_core_LoadBalancerIngress(in *corev1.LoadBalancerIngress, out *core.LoadBalancerIngress, s conversion.Scope) error {
        out.IP = in.IP
        out.Hostname = in.Hostname
        out.IPMode = (*core.LoadBalancerIPMode)(unsafe.Pointer(in.IPMode))
        out.Ports = *(*[]core.PortStatus)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_v1_LoadBalancerIngress_To_core_LoadBalancerIngress is an autogenerated conversion function.
func Convert_v1_LoadBalancerIngress_To_core_LoadBalancerIngress(in *corev1.LoadBalancerIngress, out *core.LoadBalancerIngress, s conversion.Scope) error {
        return autoConvert_v1_LoadBalancerIngress_To_core_LoadBalancerIngress(in, out, s)
}

func autoConvert_core_LoadBalancerIngress_To_v1_LoadBalancerIngress(in *core.LoadBalancerIngress, out *corev1.LoadBalancerIngress, s conversion.Scope) error {
        out.IP = in.IP
        out.Hostname = in.Hostname
        out.IPMode = (*corev1.LoadBalancerIPMode)(unsafe.Pointer(in.IPMode))
        out.Ports = *(*[]corev1.PortStatus)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_core_LoadBalancerIngress_To_v1_LoadBalancerIngress is an autogenerated conversion function.
func Convert_core_LoadBalancerIngress_To_v1_LoadBalancerIngress(in *core.LoadBalancerIngress, out *corev1.LoadBalancerIngress, s conversion.Scope) error {
        return autoConvert_core_LoadBalancerIngress_To_v1_LoadBalancerIngress(in, out, s)
}

func autoConvert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus(in *corev1.LoadBalancerStatus, out *core.LoadBalancerStatus, s conversion.Scope) error {
        out.Ingress = *(*[]core.LoadBalancerIngress)(unsafe.Pointer(&in.Ingress))
        return nil
}

// Convert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus is an autogenerated conversion function.
func Convert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus(in *corev1.LoadBalancerStatus, out *core.LoadBalancerStatus, s conversion.Scope) error {
        return autoConvert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus(in, out, s)
}

func autoConvert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus(in *core.LoadBalancerStatus, out *corev1.LoadBalancerStatus, s conversion.Scope) error {
        out.Ingress = *(*[]corev1.LoadBalancerIngress)(unsafe.Pointer(&in.Ingress))
        return nil
}

// Convert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus is an autogenerated conversion function.
func Convert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus(in *core.LoadBalancerStatus, out *corev1.LoadBalancerStatus, s conversion.Scope) error {
        return autoConvert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus(in, out, s)
}

func autoConvert_v1_LocalObjectReference_To_core_LocalObjectReference(in *corev1.LocalObjectReference, out *core.LocalObjectReference, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_v1_LocalObjectReference_To_core_LocalObjectReference is an autogenerated conversion function.
func Convert_v1_LocalObjectReference_To_core_LocalObjectReference(in *corev1.LocalObjectReference, out *core.LocalObjectReference, s conversion.Scope) error {
        return autoConvert_v1_LocalObjectReference_To_core_LocalObjectReference(in, out, s)
}

func autoConvert_core_LocalObjectReference_To_v1_LocalObjectReference(in *core.LocalObjectReference, out *corev1.LocalObjectReference, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_core_LocalObjectReference_To_v1_LocalObjectReference is an autogenerated conversion function.
func Convert_core_LocalObjectReference_To_v1_LocalObjectReference(in *core.LocalObjectReference, out *corev1.LocalObjectReference, s conversion.Scope) error {
        return autoConvert_core_LocalObjectReference_To_v1_LocalObjectReference(in, out, s)
}

func autoConvert_v1_LocalVolumeSource_To_core_LocalVolumeSource(in *corev1.LocalVolumeSource, out *core.LocalVolumeSource, s conversion.Scope) error {
        out.Path = in.Path
        out.FSType = (*string)(unsafe.Pointer(in.FSType))
        return nil
}

// Convert_v1_LocalVolumeSource_To_core_LocalVolumeSource is an autogenerated conversion function.
func Convert_v1_LocalVolumeSource_To_core_LocalVolumeSource(in *corev1.LocalVolumeSource, out *core.LocalVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_LocalVolumeSource_To_core_LocalVolumeSource(in, out, s)
}

func autoConvert_core_LocalVolumeSource_To_v1_LocalVolumeSource(in *core.LocalVolumeSource, out *corev1.LocalVolumeSource, s conversion.Scope) error {
        out.Path = in.Path
        out.FSType = (*string)(unsafe.Pointer(in.FSType))
        return nil
}

// Convert_core_LocalVolumeSource_To_v1_LocalVolumeSource is an autogenerated conversion function.
func Convert_core_LocalVolumeSource_To_v1_LocalVolumeSource(in *core.LocalVolumeSource, out *corev1.LocalVolumeSource, s conversion.Scope) error {
        return autoConvert_core_LocalVolumeSource_To_v1_LocalVolumeSource(in, out, s)
}

func autoConvert_v1_ModifyVolumeStatus_To_core_ModifyVolumeStatus(in *corev1.ModifyVolumeStatus, out *core.ModifyVolumeStatus, s conversion.Scope) error {
        out.TargetVolumeAttributesClassName = in.TargetVolumeAttributesClassName
        out.Status = core.PersistentVolumeClaimModifyVolumeStatus(in.Status)
        return nil
}

// Convert_v1_ModifyVolumeStatus_To_core_ModifyVolumeStatus is an autogenerated conversion function.
func Convert_v1_ModifyVolumeStatus_To_core_ModifyVolumeStatus(in *corev1.ModifyVolumeStatus, out *core.ModifyVolumeStatus, s conversion.Scope) error {
        return autoConvert_v1_ModifyVolumeStatus_To_core_ModifyVolumeStatus(in, out, s)
}

func autoConvert_core_ModifyVolumeStatus_To_v1_ModifyVolumeStatus(in *core.ModifyVolumeStatus, out *corev1.ModifyVolumeStatus, s conversion.Scope) error {
        out.TargetVolumeAttributesClassName = in.TargetVolumeAttributesClassName
        out.Status = corev1.PersistentVolumeClaimModifyVolumeStatus(in.Status)
        return nil
}

// Convert_core_ModifyVolumeStatus_To_v1_ModifyVolumeStatus is an autogenerated conversion function.
func Convert_core_ModifyVolumeStatus_To_v1_ModifyVolumeStatus(in *core.ModifyVolumeStatus, out *corev1.ModifyVolumeStatus, s conversion.Scope) error {
        return autoConvert_core_ModifyVolumeStatus_To_v1_ModifyVolumeStatus(in, out, s)
}

func autoConvert_v1_NFSVolumeSource_To_core_NFSVolumeSource(in *corev1.NFSVolumeSource, out *core.NFSVolumeSource, s conversion.Scope) error {
        out.Server = in.Server
        out.Path = in.Path
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_NFSVolumeSource_To_core_NFSVolumeSource is an autogenerated conversion function.
func Convert_v1_NFSVolumeSource_To_core_NFSVolumeSource(in *corev1.NFSVolumeSource, out *core.NFSVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_NFSVolumeSource_To_core_NFSVolumeSource(in, out, s)
}

func autoConvert_core_NFSVolumeSource_To_v1_NFSVolumeSource(in *core.NFSVolumeSource, out *corev1.NFSVolumeSource, s conversion.Scope) error {
        out.Server = in.Server
        out.Path = in.Path
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_NFSVolumeSource_To_v1_NFSVolumeSource is an autogenerated conversion function.
func Convert_core_NFSVolumeSource_To_v1_NFSVolumeSource(in *core.NFSVolumeSource, out *corev1.NFSVolumeSource, s conversion.Scope) error {
        return autoConvert_core_NFSVolumeSource_To_v1_NFSVolumeSource(in, out, s)
}

func autoConvert_v1_Namespace_To_core_Namespace(in *corev1.Namespace, out *core.Namespace, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_NamespaceSpec_To_core_NamespaceSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_NamespaceStatus_To_core_NamespaceStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_Namespace_To_core_Namespace is an autogenerated conversion function.
func Convert_v1_Namespace_To_core_Namespace(in *corev1.Namespace, out *core.Namespace, s conversion.Scope) error {
        return autoConvert_v1_Namespace_To_core_Namespace(in, out, s)
}

func autoConvert_core_Namespace_To_v1_Namespace(in *core.Namespace, out *corev1.Namespace, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_NamespaceSpec_To_v1_NamespaceSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_core_NamespaceStatus_To_v1_NamespaceStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_Namespace_To_v1_Namespace is an autogenerated conversion function.
func Convert_core_Namespace_To_v1_Namespace(in *core.Namespace, out *corev1.Namespace, s conversion.Scope) error {
        return autoConvert_core_Namespace_To_v1_Namespace(in, out, s)
}

func autoConvert_v1_NamespaceCondition_To_core_NamespaceCondition(in *corev1.NamespaceCondition, out *core.NamespaceCondition, s conversion.Scope) error {
        out.Type = core.NamespaceConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_NamespaceCondition_To_core_NamespaceCondition is an autogenerated conversion function.
func Convert_v1_NamespaceCondition_To_core_NamespaceCondition(in *corev1.NamespaceCondition, out *core.NamespaceCondition, s conversion.Scope) error {
        return autoConvert_v1_NamespaceCondition_To_core_NamespaceCondition(in, out, s)
}

func autoConvert_core_NamespaceCondition_To_v1_NamespaceCondition(in *core.NamespaceCondition, out *corev1.NamespaceCondition, s conversion.Scope) error {
        out.Type = corev1.NamespaceConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_core_NamespaceCondition_To_v1_NamespaceCondition is an autogenerated conversion function.
func Convert_core_NamespaceCondition_To_v1_NamespaceCondition(in *core.NamespaceCondition, out *corev1.NamespaceCondition, s conversion.Scope) error {
        return autoConvert_core_NamespaceCondition_To_v1_NamespaceCondition(in, out, s)
}

func autoConvert_v1_NamespaceList_To_core_NamespaceList(in *corev1.NamespaceList, out *core.NamespaceList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.Namespace)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_NamespaceList_To_core_NamespaceList is an autogenerated conversion function.
func Convert_v1_NamespaceList_To_core_NamespaceList(in *corev1.NamespaceList, out *core.NamespaceList, s conversion.Scope) error {
        return autoConvert_v1_NamespaceList_To_core_NamespaceList(in, out, s)
}

func autoConvert_core_NamespaceList_To_v1_NamespaceList(in *core.NamespaceList, out *corev1.NamespaceList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.Namespace)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_NamespaceList_To_v1_NamespaceList is an autogenerated conversion function.
func Convert_core_NamespaceList_To_v1_NamespaceList(in *core.NamespaceList, out *corev1.NamespaceList, s conversion.Scope) error {
        return autoConvert_core_NamespaceList_To_v1_NamespaceList(in, out, s)
}

func autoConvert_v1_NamespaceSpec_To_core_NamespaceSpec(in *corev1.NamespaceSpec, out *core.NamespaceSpec, s conversion.Scope) error {
        out.Finalizers = *(*[]core.FinalizerName)(unsafe.Pointer(&in.Finalizers))
        return nil
}

// Convert_v1_NamespaceSpec_To_core_NamespaceSpec is an autogenerated conversion function.
func Convert_v1_NamespaceSpec_To_core_NamespaceSpec(in *corev1.NamespaceSpec, out *core.NamespaceSpec, s conversion.Scope) error {
        return autoConvert_v1_NamespaceSpec_To_core_NamespaceSpec(in, out, s)
}

func autoConvert_core_NamespaceSpec_To_v1_NamespaceSpec(in *core.NamespaceSpec, out *corev1.NamespaceSpec, s conversion.Scope) error {
        out.Finalizers = *(*[]corev1.FinalizerName)(unsafe.Pointer(&in.Finalizers))
        return nil
}

// Convert_core_NamespaceSpec_To_v1_NamespaceSpec is an autogenerated conversion function.
func Convert_core_NamespaceSpec_To_v1_NamespaceSpec(in *core.NamespaceSpec, out *corev1.NamespaceSpec, s conversion.Scope) error {
        return autoConvert_core_NamespaceSpec_To_v1_NamespaceSpec(in, out, s)
}

func autoConvert_v1_NamespaceStatus_To_core_NamespaceStatus(in *corev1.NamespaceStatus, out *core.NamespaceStatus, s conversion.Scope) error {
        out.Phase = core.NamespacePhase(in.Phase)
        out.Conditions = *(*[]core.NamespaceCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1_NamespaceStatus_To_core_NamespaceStatus is an autogenerated conversion function.
func Convert_v1_NamespaceStatus_To_core_NamespaceStatus(in *corev1.NamespaceStatus, out *core.NamespaceStatus, s conversion.Scope) error {
        return autoConvert_v1_NamespaceStatus_To_core_NamespaceStatus(in, out, s)
}

func autoConvert_core_NamespaceStatus_To_v1_NamespaceStatus(in *core.NamespaceStatus, out *corev1.NamespaceStatus, s conversion.Scope) error {
        out.Phase = corev1.NamespacePhase(in.Phase)
        out.Conditions = *(*[]corev1.NamespaceCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_core_NamespaceStatus_To_v1_NamespaceStatus is an autogenerated conversion function.
func Convert_core_NamespaceStatus_To_v1_NamespaceStatus(in *core.NamespaceStatus, out *corev1.NamespaceStatus, s conversion.Scope) error {
        return autoConvert_core_NamespaceStatus_To_v1_NamespaceStatus(in, out, s)
}

func autoConvert_v1_Node_To_core_Node(in *corev1.Node, out *core.Node, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_NodeSpec_To_core_NodeSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_NodeStatus_To_core_NodeStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_Node_To_core_Node is an autogenerated conversion function.
func Convert_v1_Node_To_core_Node(in *corev1.Node, out *core.Node, s conversion.Scope) error {
        return autoConvert_v1_Node_To_core_Node(in, out, s)
}

func autoConvert_core_Node_To_v1_Node(in *core.Node, out *corev1.Node, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_NodeSpec_To_v1_NodeSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_core_NodeStatus_To_v1_NodeStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_Node_To_v1_Node is an autogenerated conversion function.
func Convert_core_Node_To_v1_Node(in *core.Node, out *corev1.Node, s conversion.Scope) error {
        return autoConvert_core_Node_To_v1_Node(in, out, s)
}

func autoConvert_v1_NodeAddress_To_core_NodeAddress(in *corev1.NodeAddress, out *core.NodeAddress, s conversion.Scope) error {
        out.Type = core.NodeAddressType(in.Type)
        out.Address = in.Address
        return nil
}

// Convert_v1_NodeAddress_To_core_NodeAddress is an autogenerated conversion function.
func Convert_v1_NodeAddress_To_core_NodeAddress(in *corev1.NodeAddress, out *core.NodeAddress, s conversion.Scope) error {
        return autoConvert_v1_NodeAddress_To_core_NodeAddress(in, out, s)
}

func autoConvert_core_NodeAddress_To_v1_NodeAddress(in *core.NodeAddress, out *corev1.NodeAddress, s conversion.Scope) error {
        out.Type = corev1.NodeAddressType(in.Type)
        out.Address = in.Address
        return nil
}

// Convert_core_NodeAddress_To_v1_NodeAddress is an autogenerated conversion function.
func Convert_core_NodeAddress_To_v1_NodeAddress(in *core.NodeAddress, out *corev1.NodeAddress, s conversion.Scope) error {
        return autoConvert_core_NodeAddress_To_v1_NodeAddress(in, out, s)
}

func autoConvert_v1_NodeAffinity_To_core_NodeAffinity(in *corev1.NodeAffinity, out *core.NodeAffinity, s conversion.Scope) error {
        out.RequiredDuringSchedulingIgnoredDuringExecution = (*core.NodeSelector)(unsafe.Pointer(in.RequiredDuringSchedulingIgnoredDuringExecution))
        out.PreferredDuringSchedulingIgnoredDuringExecution = *(*[]core.PreferredSchedulingTerm)(unsafe.Pointer(&in.PreferredDuringSchedulingIgnoredDuringExecution))
        return nil
}

// Convert_v1_NodeAffinity_To_core_NodeAffinity is an autogenerated conversion function.
func Convert_v1_NodeAffinity_To_core_NodeAffinity(in *corev1.NodeAffinity, out *core.NodeAffinity, s conversion.Scope) error {
        return autoConvert_v1_NodeAffinity_To_core_NodeAffinity(in, out, s)
}

func autoConvert_core_NodeAffinity_To_v1_NodeAffinity(in *core.NodeAffinity, out *corev1.NodeAffinity, s conversion.Scope) error {
        out.RequiredDuringSchedulingIgnoredDuringExecution = (*corev1.NodeSelector)(unsafe.Pointer(in.RequiredDuringSchedulingIgnoredDuringExecution))
        out.PreferredDuringSchedulingIgnoredDuringExecution = *(*[]corev1.PreferredSchedulingTerm)(unsafe.Pointer(&in.PreferredDuringSchedulingIgnoredDuringExecution))
        return nil
}

// Convert_core_NodeAffinity_To_v1_NodeAffinity is an autogenerated conversion function.
func Convert_core_NodeAffinity_To_v1_NodeAffinity(in *core.NodeAffinity, out *corev1.NodeAffinity, s conversion.Scope) error {
        return autoConvert_core_NodeAffinity_To_v1_NodeAffinity(in, out, s)
}

func autoConvert_v1_NodeCondition_To_core_NodeCondition(in *corev1.NodeCondition, out *core.NodeCondition, s conversion.Scope) error {
        out.Type = core.NodeConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastHeartbeatTime = in.LastHeartbeatTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_NodeCondition_To_core_NodeCondition is an autogenerated conversion function.
func Convert_v1_NodeCondition_To_core_NodeCondition(in *corev1.NodeCondition, out *core.NodeCondition, s conversion.Scope) error {
        return autoConvert_v1_NodeCondition_To_core_NodeCondition(in, out, s)
}

func autoConvert_core_NodeCondition_To_v1_NodeCondition(in *core.NodeCondition, out *corev1.NodeCondition, s conversion.Scope) error {
        out.Type = corev1.NodeConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastHeartbeatTime = in.LastHeartbeatTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_core_NodeCondition_To_v1_NodeCondition is an autogenerated conversion function.
func Convert_core_NodeCondition_To_v1_NodeCondition(in *core.NodeCondition, out *corev1.NodeCondition, s conversion.Scope) error {
        return autoConvert_core_NodeCondition_To_v1_NodeCondition(in, out, s)
}

func autoConvert_v1_NodeConfigSource_To_core_NodeConfigSource(in *corev1.NodeConfigSource, out *core.NodeConfigSource, s conversion.Scope) error {
        out.ConfigMap = (*core.ConfigMapNodeConfigSource)(unsafe.Pointer(in.ConfigMap))
        return nil
}

// Convert_v1_NodeConfigSource_To_core_NodeConfigSource is an autogenerated conversion function.
func Convert_v1_NodeConfigSource_To_core_NodeConfigSource(in *corev1.NodeConfigSource, out *core.NodeConfigSource, s conversion.Scope) error {
        return autoConvert_v1_NodeConfigSource_To_core_NodeConfigSource(in, out, s)
}

func autoConvert_core_NodeConfigSource_To_v1_NodeConfigSource(in *core.NodeConfigSource, out *corev1.NodeConfigSource, s conversion.Scope) error {
        out.ConfigMap = (*corev1.ConfigMapNodeConfigSource)(unsafe.Pointer(in.ConfigMap))
        return nil
}

// Convert_core_NodeConfigSource_To_v1_NodeConfigSource is an autogenerated conversion function.
func Convert_core_NodeConfigSource_To_v1_NodeConfigSource(in *core.NodeConfigSource, out *corev1.NodeConfigSource, s conversion.Scope) error {
        return autoConvert_core_NodeConfigSource_To_v1_NodeConfigSource(in, out, s)
}

func autoConvert_v1_NodeConfigStatus_To_core_NodeConfigStatus(in *corev1.NodeConfigStatus, out *core.NodeConfigStatus, s conversion.Scope) error {
        out.Assigned = (*core.NodeConfigSource)(unsafe.Pointer(in.Assigned))
        out.Active = (*core.NodeConfigSource)(unsafe.Pointer(in.Active))
        out.LastKnownGood = (*core.NodeConfigSource)(unsafe.Pointer(in.LastKnownGood))
        out.Error = in.Error
        return nil
}

// Convert_v1_NodeConfigStatus_To_core_NodeConfigStatus is an autogenerated conversion function.
func Convert_v1_NodeConfigStatus_To_core_NodeConfigStatus(in *corev1.NodeConfigStatus, out *core.NodeConfigStatus, s conversion.Scope) error {
        return autoConvert_v1_NodeConfigStatus_To_core_NodeConfigStatus(in, out, s)
}

func autoConvert_core_NodeConfigStatus_To_v1_NodeConfigStatus(in *core.NodeConfigStatus, out *corev1.NodeConfigStatus, s conversion.Scope) error {
        out.Assigned = (*corev1.NodeConfigSource)(unsafe.Pointer(in.Assigned))
        out.Active = (*corev1.NodeConfigSource)(unsafe.Pointer(in.Active))
        out.LastKnownGood = (*corev1.NodeConfigSource)(unsafe.Pointer(in.LastKnownGood))
        out.Error = in.Error
        return nil
}

// Convert_core_NodeConfigStatus_To_v1_NodeConfigStatus is an autogenerated conversion function.
func Convert_core_NodeConfigStatus_To_v1_NodeConfigStatus(in *core.NodeConfigStatus, out *corev1.NodeConfigStatus, s conversion.Scope) error {
        return autoConvert_core_NodeConfigStatus_To_v1_NodeConfigStatus(in, out, s)
}

func autoConvert_v1_NodeDaemonEndpoints_To_core_NodeDaemonEndpoints(in *corev1.NodeDaemonEndpoints, out *core.NodeDaemonEndpoints, s conversion.Scope) error {
        if err := Convert_v1_DaemonEndpoint_To_core_DaemonEndpoint(&in.KubeletEndpoint, &out.KubeletEndpoint, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_NodeDaemonEndpoints_To_core_NodeDaemonEndpoints is an autogenerated conversion function.
func Convert_v1_NodeDaemonEndpoints_To_core_NodeDaemonEndpoints(in *corev1.NodeDaemonEndpoints, out *core.NodeDaemonEndpoints, s conversion.Scope) error {
        return autoConvert_v1_NodeDaemonEndpoints_To_core_NodeDaemonEndpoints(in, out, s)
}

func autoConvert_core_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(in *core.NodeDaemonEndpoints, out *corev1.NodeDaemonEndpoints, s conversion.Scope) error {
        if err := Convert_core_DaemonEndpoint_To_v1_DaemonEndpoint(&in.KubeletEndpoint, &out.KubeletEndpoint, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints is an autogenerated conversion function.
func Convert_core_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(in *core.NodeDaemonEndpoints, out *corev1.NodeDaemonEndpoints, s conversion.Scope) error {
        return autoConvert_core_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(in, out, s)
}

func autoConvert_v1_NodeFeatures_To_core_NodeFeatures(in *corev1.NodeFeatures, out *core.NodeFeatures, s conversion.Scope) error {
        out.SupplementalGroupsPolicy = (*bool)(unsafe.Pointer(in.SupplementalGroupsPolicy))
        return nil
}

// Convert_v1_NodeFeatures_To_core_NodeFeatures is an autogenerated conversion function.
func Convert_v1_NodeFeatures_To_core_NodeFeatures(in *corev1.NodeFeatures, out *core.NodeFeatures, s conversion.Scope) error {
        return autoConvert_v1_NodeFeatures_To_core_NodeFeatures(in, out, s)
}

func autoConvert_core_NodeFeatures_To_v1_NodeFeatures(in *core.NodeFeatures, out *corev1.NodeFeatures, s conversion.Scope) error {
        out.SupplementalGroupsPolicy = (*bool)(unsafe.Pointer(in.SupplementalGroupsPolicy))
        return nil
}

// Convert_core_NodeFeatures_To_v1_NodeFeatures is an autogenerated conversion function.
func Convert_core_NodeFeatures_To_v1_NodeFeatures(in *core.NodeFeatures, out *corev1.NodeFeatures, s conversion.Scope) error {
        return autoConvert_core_NodeFeatures_To_v1_NodeFeatures(in, out, s)
}

func autoConvert_v1_NodeList_To_core_NodeList(in *corev1.NodeList, out *core.NodeList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.Node, len(*in))
                for i := range *in {
                        if err := Convert_v1_Node_To_core_Node(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_NodeList_To_core_NodeList is an autogenerated conversion function.
func Convert_v1_NodeList_To_core_NodeList(in *corev1.NodeList, out *core.NodeList, s conversion.Scope) error {
        return autoConvert_v1_NodeList_To_core_NodeList(in, out, s)
}

func autoConvert_core_NodeList_To_v1_NodeList(in *core.NodeList, out *corev1.NodeList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]corev1.Node, len(*in))
                for i := range *in {
                        if err := Convert_core_Node_To_v1_Node(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_NodeList_To_v1_NodeList is an autogenerated conversion function.
func Convert_core_NodeList_To_v1_NodeList(in *core.NodeList, out *corev1.NodeList, s conversion.Scope) error {
        return autoConvert_core_NodeList_To_v1_NodeList(in, out, s)
}

func autoConvert_v1_NodeProxyOptions_To_core_NodeProxyOptions(in *corev1.NodeProxyOptions, out *core.NodeProxyOptions, s conversion.Scope) error {
        out.Path = in.Path
        return nil
}

// Convert_v1_NodeProxyOptions_To_core_NodeProxyOptions is an autogenerated conversion function.
func Convert_v1_NodeProxyOptions_To_core_NodeProxyOptions(in *corev1.NodeProxyOptions, out *core.NodeProxyOptions, s conversion.Scope) error {
        return autoConvert_v1_NodeProxyOptions_To_core_NodeProxyOptions(in, out, s)
}

func autoConvert_core_NodeProxyOptions_To_v1_NodeProxyOptions(in *core.NodeProxyOptions, out *corev1.NodeProxyOptions, s conversion.Scope) error {
        out.Path = in.Path
        return nil
}

// Convert_core_NodeProxyOptions_To_v1_NodeProxyOptions is an autogenerated conversion function.
func Convert_core_NodeProxyOptions_To_v1_NodeProxyOptions(in *core.NodeProxyOptions, out *corev1.NodeProxyOptions, s conversion.Scope) error {
        return autoConvert_core_NodeProxyOptions_To_v1_NodeProxyOptions(in, out, s)
}

func autoConvert_url_Values_To_v1_NodeProxyOptions(in *url.Values, out *corev1.NodeProxyOptions, s conversion.Scope) error {
        // WARNING: Field TypeMeta does not have json tag, skipping.

        if values, ok := map[string][]string(*in)["path"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_string(&values, &out.Path, s); err != nil {
                        return err
                }
        } else {
                out.Path = ""
        }
        return nil
}

// Convert_url_Values_To_v1_NodeProxyOptions is an autogenerated conversion function.
func Convert_url_Values_To_v1_NodeProxyOptions(in *url.Values, out *corev1.NodeProxyOptions, s conversion.Scope) error {
        return autoConvert_url_Values_To_v1_NodeProxyOptions(in, out, s)
}

func autoConvert_v1_NodeRuntimeHandler_To_core_NodeRuntimeHandler(in *corev1.NodeRuntimeHandler, out *core.NodeRuntimeHandler, s conversion.Scope) error {
        out.Name = in.Name
        out.Features = (*core.NodeRuntimeHandlerFeatures)(unsafe.Pointer(in.Features))
        return nil
}

// Convert_v1_NodeRuntimeHandler_To_core_NodeRuntimeHandler is an autogenerated conversion function.
func Convert_v1_NodeRuntimeHandler_To_core_NodeRuntimeHandler(in *corev1.NodeRuntimeHandler, out *core.NodeRuntimeHandler, s conversion.Scope) error {
        return autoConvert_v1_NodeRuntimeHandler_To_core_NodeRuntimeHandler(in, out, s)
}

func autoConvert_core_NodeRuntimeHandler_To_v1_NodeRuntimeHandler(in *core.NodeRuntimeHandler, out *corev1.NodeRuntimeHandler, s conversion.Scope) error {
        out.Name = in.Name
        out.Features = (*corev1.NodeRuntimeHandlerFeatures)(unsafe.Pointer(in.Features))
        return nil
}

// Convert_core_NodeRuntimeHandler_To_v1_NodeRuntimeHandler is an autogenerated conversion function.
func Convert_core_NodeRuntimeHandler_To_v1_NodeRuntimeHandler(in *core.NodeRuntimeHandler, out *corev1.NodeRuntimeHandler, s conversion.Scope) error {
        return autoConvert_core_NodeRuntimeHandler_To_v1_NodeRuntimeHandler(in, out, s)
}

func autoConvert_v1_NodeRuntimeHandlerFeatures_To_core_NodeRuntimeHandlerFeatures(in *corev1.NodeRuntimeHandlerFeatures, out *core.NodeRuntimeHandlerFeatures, s conversion.Scope) error {
        out.RecursiveReadOnlyMounts = (*bool)(unsafe.Pointer(in.RecursiveReadOnlyMounts))
        out.UserNamespaces = (*bool)(unsafe.Pointer(in.UserNamespaces))
        return nil
}

// Convert_v1_NodeRuntimeHandlerFeatures_To_core_NodeRuntimeHandlerFeatures is an autogenerated conversion function.
func Convert_v1_NodeRuntimeHandlerFeatures_To_core_NodeRuntimeHandlerFeatures(in *corev1.NodeRuntimeHandlerFeatures, out *core.NodeRuntimeHandlerFeatures, s conversion.Scope) error {
        return autoConvert_v1_NodeRuntimeHandlerFeatures_To_core_NodeRuntimeHandlerFeatures(in, out, s)
}

func autoConvert_core_NodeRuntimeHandlerFeatures_To_v1_NodeRuntimeHandlerFeatures(in *core.NodeRuntimeHandlerFeatures, out *corev1.NodeRuntimeHandlerFeatures, s conversion.Scope) error {
        out.RecursiveReadOnlyMounts = (*bool)(unsafe.Pointer(in.RecursiveReadOnlyMounts))
        out.UserNamespaces = (*bool)(unsafe.Pointer(in.UserNamespaces))
        return nil
}

// Convert_core_NodeRuntimeHandlerFeatures_To_v1_NodeRuntimeHandlerFeatures is an autogenerated conversion function.
func Convert_core_NodeRuntimeHandlerFeatures_To_v1_NodeRuntimeHandlerFeatures(in *core.NodeRuntimeHandlerFeatures, out *corev1.NodeRuntimeHandlerFeatures, s conversion.Scope) error {
        return autoConvert_core_NodeRuntimeHandlerFeatures_To_v1_NodeRuntimeHandlerFeatures(in, out, s)
}

func autoConvert_v1_NodeSelector_To_core_NodeSelector(in *corev1.NodeSelector, out *core.NodeSelector, s conversion.Scope) error {
        out.NodeSelectorTerms = *(*[]core.NodeSelectorTerm)(unsafe.Pointer(&in.NodeSelectorTerms))
        return nil
}

// Convert_v1_NodeSelector_To_core_NodeSelector is an autogenerated conversion function.
func Convert_v1_NodeSelector_To_core_NodeSelector(in *corev1.NodeSelector, out *core.NodeSelector, s conversion.Scope) error {
        return autoConvert_v1_NodeSelector_To_core_NodeSelector(in, out, s)
}

func autoConvert_core_NodeSelector_To_v1_NodeSelector(in *core.NodeSelector, out *corev1.NodeSelector, s conversion.Scope) error {
        out.NodeSelectorTerms = *(*[]corev1.NodeSelectorTerm)(unsafe.Pointer(&in.NodeSelectorTerms))
        return nil
}

// Convert_core_NodeSelector_To_v1_NodeSelector is an autogenerated conversion function.
func Convert_core_NodeSelector_To_v1_NodeSelector(in *core.NodeSelector, out *corev1.NodeSelector, s conversion.Scope) error {
        return autoConvert_core_NodeSelector_To_v1_NodeSelector(in, out, s)
}

func autoConvert_v1_NodeSelectorRequirement_To_core_NodeSelectorRequirement(in *corev1.NodeSelectorRequirement, out *core.NodeSelectorRequirement, s conversion.Scope) error {
        out.Key = in.Key
        out.Operator = core.NodeSelectorOperator(in.Operator)
        out.Values = *(*[]string)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_v1_NodeSelectorRequirement_To_core_NodeSelectorRequirement is an autogenerated conversion function.
func Convert_v1_NodeSelectorRequirement_To_core_NodeSelectorRequirement(in *corev1.NodeSelectorRequirement, out *core.NodeSelectorRequirement, s conversion.Scope) error {
        return autoConvert_v1_NodeSelectorRequirement_To_core_NodeSelectorRequirement(in, out, s)
}

func autoConvert_core_NodeSelectorRequirement_To_v1_NodeSelectorRequirement(in *core.NodeSelectorRequirement, out *corev1.NodeSelectorRequirement, s conversion.Scope) error {
        out.Key = in.Key
        out.Operator = corev1.NodeSelectorOperator(in.Operator)
        out.Values = *(*[]string)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_core_NodeSelectorRequirement_To_v1_NodeSelectorRequirement is an autogenerated conversion function.
func Convert_core_NodeSelectorRequirement_To_v1_NodeSelectorRequirement(in *core.NodeSelectorRequirement, out *corev1.NodeSelectorRequirement, s conversion.Scope) error {
        return autoConvert_core_NodeSelectorRequirement_To_v1_NodeSelectorRequirement(in, out, s)
}

func autoConvert_v1_NodeSelectorTerm_To_core_NodeSelectorTerm(in *corev1.NodeSelectorTerm, out *core.NodeSelectorTerm, s conversion.Scope) error {
        out.MatchExpressions = *(*[]core.NodeSelectorRequirement)(unsafe.Pointer(&in.MatchExpressions))
        out.MatchFields = *(*[]core.NodeSelectorRequirement)(unsafe.Pointer(&in.MatchFields))
        return nil
}

// Convert_v1_NodeSelectorTerm_To_core_NodeSelectorTerm is an autogenerated conversion function.
func Convert_v1_NodeSelectorTerm_To_core_NodeSelectorTerm(in *corev1.NodeSelectorTerm, out *core.NodeSelectorTerm, s conversion.Scope) error {
        return autoConvert_v1_NodeSelectorTerm_To_core_NodeSelectorTerm(in, out, s)
}

func autoConvert_core_NodeSelectorTerm_To_v1_NodeSelectorTerm(in *core.NodeSelectorTerm, out *corev1.NodeSelectorTerm, s conversion.Scope) error {
        out.MatchExpressions = *(*[]corev1.NodeSelectorRequirement)(unsafe.Pointer(&in.MatchExpressions))
        out.MatchFields = *(*[]corev1.NodeSelectorRequirement)(unsafe.Pointer(&in.MatchFields))
        return nil
}

// Convert_core_NodeSelectorTerm_To_v1_NodeSelectorTerm is an autogenerated conversion function.
func Convert_core_NodeSelectorTerm_To_v1_NodeSelectorTerm(in *core.NodeSelectorTerm, out *corev1.NodeSelectorTerm, s conversion.Scope) error {
        return autoConvert_core_NodeSelectorTerm_To_v1_NodeSelectorTerm(in, out, s)
}

func autoConvert_v1_NodeSpec_To_core_NodeSpec(in *corev1.NodeSpec, out *core.NodeSpec, s conversion.Scope) error {
        // WARNING: in.PodCIDR requires manual conversion: does not exist in peer-type
        out.PodCIDRs = *(*[]string)(unsafe.Pointer(&in.PodCIDRs))
        out.ProviderID = in.ProviderID
        out.Unschedulable = in.Unschedulable
        out.Taints = *(*[]core.Taint)(unsafe.Pointer(&in.Taints))
        out.ConfigSource = (*core.NodeConfigSource)(unsafe.Pointer(in.ConfigSource))
        out.DoNotUseExternalID = in.DoNotUseExternalID
        return nil
}

func autoConvert_core_NodeSpec_To_v1_NodeSpec(in *core.NodeSpec, out *corev1.NodeSpec, s conversion.Scope) error {
        out.PodCIDRs = *(*[]string)(unsafe.Pointer(&in.PodCIDRs))
        out.ProviderID = in.ProviderID
        out.Unschedulable = in.Unschedulable
        out.Taints = *(*[]corev1.Taint)(unsafe.Pointer(&in.Taints))
        out.ConfigSource = (*corev1.NodeConfigSource)(unsafe.Pointer(in.ConfigSource))
        out.DoNotUseExternalID = in.DoNotUseExternalID
        return nil
}

func autoConvert_v1_NodeStatus_To_core_NodeStatus(in *corev1.NodeStatus, out *core.NodeStatus, s conversion.Scope) error {
        out.Capacity = *(*core.ResourceList)(unsafe.Pointer(&in.Capacity))
        out.Allocatable = *(*core.ResourceList)(unsafe.Pointer(&in.Allocatable))
        out.Phase = core.NodePhase(in.Phase)
        out.Conditions = *(*[]core.NodeCondition)(unsafe.Pointer(&in.Conditions))
        out.Addresses = *(*[]core.NodeAddress)(unsafe.Pointer(&in.Addresses))
        if err := Convert_v1_NodeDaemonEndpoints_To_core_NodeDaemonEndpoints(&in.DaemonEndpoints, &out.DaemonEndpoints, s); err != nil {
                return err
        }
        if err := Convert_v1_NodeSystemInfo_To_core_NodeSystemInfo(&in.NodeInfo, &out.NodeInfo, s); err != nil {
                return err
        }
        out.Images = *(*[]core.ContainerImage)(unsafe.Pointer(&in.Images))
        out.VolumesInUse = *(*[]core.UniqueVolumeName)(unsafe.Pointer(&in.VolumesInUse))
        out.VolumesAttached = *(*[]core.AttachedVolume)(unsafe.Pointer(&in.VolumesAttached))
        out.Config = (*core.NodeConfigStatus)(unsafe.Pointer(in.Config))
        out.RuntimeHandlers = *(*[]core.NodeRuntimeHandler)(unsafe.Pointer(&in.RuntimeHandlers))
        out.Features = (*core.NodeFeatures)(unsafe.Pointer(in.Features))
        return nil
}

// Convert_v1_NodeStatus_To_core_NodeStatus is an autogenerated conversion function.
func Convert_v1_NodeStatus_To_core_NodeStatus(in *corev1.NodeStatus, out *core.NodeStatus, s conversion.Scope) error {
        return autoConvert_v1_NodeStatus_To_core_NodeStatus(in, out, s)
}

func autoConvert_core_NodeStatus_To_v1_NodeStatus(in *core.NodeStatus, out *corev1.NodeStatus, s conversion.Scope) error {
        out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
        out.Allocatable = *(*corev1.ResourceList)(unsafe.Pointer(&in.Allocatable))
        out.Phase = corev1.NodePhase(in.Phase)
        out.Conditions = *(*[]corev1.NodeCondition)(unsafe.Pointer(&in.Conditions))
        out.Addresses = *(*[]corev1.NodeAddress)(unsafe.Pointer(&in.Addresses))
        if err := Convert_core_NodeDaemonEndpoints_To_v1_NodeDaemonEndpoints(&in.DaemonEndpoints, &out.DaemonEndpoints, s); err != nil {
                return err
        }
        if err := Convert_core_NodeSystemInfo_To_v1_NodeSystemInfo(&in.NodeInfo, &out.NodeInfo, s); err != nil {
                return err
        }
        out.Images = *(*[]corev1.ContainerImage)(unsafe.Pointer(&in.Images))
        out.VolumesInUse = *(*[]corev1.UniqueVolumeName)(unsafe.Pointer(&in.VolumesInUse))
        out.VolumesAttached = *(*[]corev1.AttachedVolume)(unsafe.Pointer(&in.VolumesAttached))
        out.Config = (*corev1.NodeConfigStatus)(unsafe.Pointer(in.Config))
        out.RuntimeHandlers = *(*[]corev1.NodeRuntimeHandler)(unsafe.Pointer(&in.RuntimeHandlers))
        out.Features = (*corev1.NodeFeatures)(unsafe.Pointer(in.Features))
        return nil
}

// Convert_core_NodeStatus_To_v1_NodeStatus is an autogenerated conversion function.
func Convert_core_NodeStatus_To_v1_NodeStatus(in *core.NodeStatus, out *corev1.NodeStatus, s conversion.Scope) error {
        return autoConvert_core_NodeStatus_To_v1_NodeStatus(in, out, s)
}

func autoConvert_v1_NodeSwapStatus_To_core_NodeSwapStatus(in *corev1.NodeSwapStatus, out *core.NodeSwapStatus, s conversion.Scope) error {
        out.Capacity = (*int64)(unsafe.Pointer(in.Capacity))
        return nil
}

// Convert_v1_NodeSwapStatus_To_core_NodeSwapStatus is an autogenerated conversion function.
func Convert_v1_NodeSwapStatus_To_core_NodeSwapStatus(in *corev1.NodeSwapStatus, out *core.NodeSwapStatus, s conversion.Scope) error {
        return autoConvert_v1_NodeSwapStatus_To_core_NodeSwapStatus(in, out, s)
}

func autoConvert_core_NodeSwapStatus_To_v1_NodeSwapStatus(in *core.NodeSwapStatus, out *corev1.NodeSwapStatus, s conversion.Scope) error {
        out.Capacity = (*int64)(unsafe.Pointer(in.Capacity))
        return nil
}

// Convert_core_NodeSwapStatus_To_v1_NodeSwapStatus is an autogenerated conversion function.
func Convert_core_NodeSwapStatus_To_v1_NodeSwapStatus(in *core.NodeSwapStatus, out *corev1.NodeSwapStatus, s conversion.Scope) error {
        return autoConvert_core_NodeSwapStatus_To_v1_NodeSwapStatus(in, out, s)
}

func autoConvert_v1_NodeSystemInfo_To_core_NodeSystemInfo(in *corev1.NodeSystemInfo, out *core.NodeSystemInfo, s conversion.Scope) error {
        out.MachineID = in.MachineID
        out.SystemUUID = in.SystemUUID
        out.BootID = in.BootID
        out.KernelVersion = in.KernelVersion
        out.OSImage = in.OSImage
        out.ContainerRuntimeVersion = in.ContainerRuntimeVersion
        out.KubeletVersion = in.KubeletVersion
        out.KubeProxyVersion = in.KubeProxyVersion
        out.OperatingSystem = in.OperatingSystem
        out.Architecture = in.Architecture
        out.Swap = (*core.NodeSwapStatus)(unsafe.Pointer(in.Swap))
        return nil
}

// Convert_v1_NodeSystemInfo_To_core_NodeSystemInfo is an autogenerated conversion function.
func Convert_v1_NodeSystemInfo_To_core_NodeSystemInfo(in *corev1.NodeSystemInfo, out *core.NodeSystemInfo, s conversion.Scope) error {
        return autoConvert_v1_NodeSystemInfo_To_core_NodeSystemInfo(in, out, s)
}

func autoConvert_core_NodeSystemInfo_To_v1_NodeSystemInfo(in *core.NodeSystemInfo, out *corev1.NodeSystemInfo, s conversion.Scope) error {
        out.MachineID = in.MachineID
        out.SystemUUID = in.SystemUUID
        out.BootID = in.BootID
        out.KernelVersion = in.KernelVersion
        out.OSImage = in.OSImage
        out.ContainerRuntimeVersion = in.ContainerRuntimeVersion
        out.KubeletVersion = in.KubeletVersion
        out.KubeProxyVersion = in.KubeProxyVersion
        out.OperatingSystem = in.OperatingSystem
        out.Architecture = in.Architecture
        out.Swap = (*corev1.NodeSwapStatus)(unsafe.Pointer(in.Swap))
        return nil
}

// Convert_core_NodeSystemInfo_To_v1_NodeSystemInfo is an autogenerated conversion function.
func Convert_core_NodeSystemInfo_To_v1_NodeSystemInfo(in *core.NodeSystemInfo, out *corev1.NodeSystemInfo, s conversion.Scope) error {
        return autoConvert_core_NodeSystemInfo_To_v1_NodeSystemInfo(in, out, s)
}

func autoConvert_v1_ObjectFieldSelector_To_core_ObjectFieldSelector(in *corev1.ObjectFieldSelector, out *core.ObjectFieldSelector, s conversion.Scope) error {
        out.APIVersion = in.APIVersion
        out.FieldPath = in.FieldPath
        return nil
}

// Convert_v1_ObjectFieldSelector_To_core_ObjectFieldSelector is an autogenerated conversion function.
func Convert_v1_ObjectFieldSelector_To_core_ObjectFieldSelector(in *corev1.ObjectFieldSelector, out *core.ObjectFieldSelector, s conversion.Scope) error {
        return autoConvert_v1_ObjectFieldSelector_To_core_ObjectFieldSelector(in, out, s)
}

func autoConvert_core_ObjectFieldSelector_To_v1_ObjectFieldSelector(in *core.ObjectFieldSelector, out *corev1.ObjectFieldSelector, s conversion.Scope) error {
        out.APIVersion = in.APIVersion
        out.FieldPath = in.FieldPath
        return nil
}

// Convert_core_ObjectFieldSelector_To_v1_ObjectFieldSelector is an autogenerated conversion function.
func Convert_core_ObjectFieldSelector_To_v1_ObjectFieldSelector(in *core.ObjectFieldSelector, out *corev1.ObjectFieldSelector, s conversion.Scope) error {
        return autoConvert_core_ObjectFieldSelector_To_v1_ObjectFieldSelector(in, out, s)
}

func autoConvert_v1_ObjectReference_To_core_ObjectReference(in *corev1.ObjectReference, out *core.ObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Namespace = in.Namespace
        out.Name = in.Name
        out.UID = types.UID(in.UID)
        out.APIVersion = in.APIVersion
        out.ResourceVersion = in.ResourceVersion
        out.FieldPath = in.FieldPath
        return nil
}

// Convert_v1_ObjectReference_To_core_ObjectReference is an autogenerated conversion function.
func Convert_v1_ObjectReference_To_core_ObjectReference(in *corev1.ObjectReference, out *core.ObjectReference, s conversion.Scope) error {
        return autoConvert_v1_ObjectReference_To_core_ObjectReference(in, out, s)
}

func autoConvert_core_ObjectReference_To_v1_ObjectReference(in *core.ObjectReference, out *corev1.ObjectReference, s conversion.Scope) error {
        out.Kind = in.Kind
        out.Namespace = in.Namespace
        out.Name = in.Name
        out.UID = types.UID(in.UID)
        out.APIVersion = in.APIVersion
        out.ResourceVersion = in.ResourceVersion
        out.FieldPath = in.FieldPath
        return nil
}

// Convert_core_ObjectReference_To_v1_ObjectReference is an autogenerated conversion function.
func Convert_core_ObjectReference_To_v1_ObjectReference(in *core.ObjectReference, out *corev1.ObjectReference, s conversion.Scope) error {
        return autoConvert_core_ObjectReference_To_v1_ObjectReference(in, out, s)
}

func autoConvert_v1_PersistentVolume_To_core_PersistentVolume(in *corev1.PersistentVolume, out *core.PersistentVolume, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_PersistentVolumeSpec_To_core_PersistentVolumeSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_PersistentVolumeStatus_To_core_PersistentVolumeStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_PersistentVolume_To_core_PersistentVolume is an autogenerated conversion function.
func Convert_v1_PersistentVolume_To_core_PersistentVolume(in *corev1.PersistentVolume, out *core.PersistentVolume, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolume_To_core_PersistentVolume(in, out, s)
}

func autoConvert_core_PersistentVolume_To_v1_PersistentVolume(in *core.PersistentVolume, out *corev1.PersistentVolume, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_core_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_PersistentVolume_To_v1_PersistentVolume is an autogenerated conversion function.
func Convert_core_PersistentVolume_To_v1_PersistentVolume(in *core.PersistentVolume, out *corev1.PersistentVolume, s conversion.Scope) error {
        return autoConvert_core_PersistentVolume_To_v1_PersistentVolume(in, out, s)
}

func autoConvert_v1_PersistentVolumeClaim_To_core_PersistentVolumeClaim(in *corev1.PersistentVolumeClaim, out *core.PersistentVolumeClaim, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_PersistentVolumeClaimSpec_To_core_PersistentVolumeClaimSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_PersistentVolumeClaimStatus_To_core_PersistentVolumeClaimStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_PersistentVolumeClaim_To_core_PersistentVolumeClaim is an autogenerated conversion function.
func Convert_v1_PersistentVolumeClaim_To_core_PersistentVolumeClaim(in *corev1.PersistentVolumeClaim, out *core.PersistentVolumeClaim, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeClaim_To_core_PersistentVolumeClaim(in, out, s)
}

func autoConvert_core_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(in *core.PersistentVolumeClaim, out *corev1.PersistentVolumeClaim, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_core_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_PersistentVolumeClaim_To_v1_PersistentVolumeClaim is an autogenerated conversion function.
func Convert_core_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(in *core.PersistentVolumeClaim, out *corev1.PersistentVolumeClaim, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeClaim_To_v1_PersistentVolumeClaim(in, out, s)
}

func autoConvert_v1_PersistentVolumeClaimCondition_To_core_PersistentVolumeClaimCondition(in *corev1.PersistentVolumeClaimCondition, out *core.PersistentVolumeClaimCondition, s conversion.Scope) error {
        out.Type = core.PersistentVolumeClaimConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastProbeTime = in.LastProbeTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_PersistentVolumeClaimCondition_To_core_PersistentVolumeClaimCondition is an autogenerated conversion function.
func Convert_v1_PersistentVolumeClaimCondition_To_core_PersistentVolumeClaimCondition(in *corev1.PersistentVolumeClaimCondition, out *core.PersistentVolumeClaimCondition, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeClaimCondition_To_core_PersistentVolumeClaimCondition(in, out, s)
}

func autoConvert_core_PersistentVolumeClaimCondition_To_v1_PersistentVolumeClaimCondition(in *core.PersistentVolumeClaimCondition, out *corev1.PersistentVolumeClaimCondition, s conversion.Scope) error {
        out.Type = corev1.PersistentVolumeClaimConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastProbeTime = in.LastProbeTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_core_PersistentVolumeClaimCondition_To_v1_PersistentVolumeClaimCondition is an autogenerated conversion function.
func Convert_core_PersistentVolumeClaimCondition_To_v1_PersistentVolumeClaimCondition(in *core.PersistentVolumeClaimCondition, out *corev1.PersistentVolumeClaimCondition, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeClaimCondition_To_v1_PersistentVolumeClaimCondition(in, out, s)
}

func autoConvert_v1_PersistentVolumeClaimList_To_core_PersistentVolumeClaimList(in *corev1.PersistentVolumeClaimList, out *core.PersistentVolumeClaimList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.PersistentVolumeClaim)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_PersistentVolumeClaimList_To_core_PersistentVolumeClaimList is an autogenerated conversion function.
func Convert_v1_PersistentVolumeClaimList_To_core_PersistentVolumeClaimList(in *corev1.PersistentVolumeClaimList, out *core.PersistentVolumeClaimList, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeClaimList_To_core_PersistentVolumeClaimList(in, out, s)
}

func autoConvert_core_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList(in *core.PersistentVolumeClaimList, out *corev1.PersistentVolumeClaimList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.PersistentVolumeClaim)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList is an autogenerated conversion function.
func Convert_core_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList(in *core.PersistentVolumeClaimList, out *corev1.PersistentVolumeClaimList, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeClaimList_To_v1_PersistentVolumeClaimList(in, out, s)
}

func autoConvert_v1_PersistentVolumeClaimSpec_To_core_PersistentVolumeClaimSpec(in *corev1.PersistentVolumeClaimSpec, out *core.PersistentVolumeClaimSpec, s conversion.Scope) error {
        out.AccessModes = *(*[]core.PersistentVolumeAccessMode)(unsafe.Pointer(&in.AccessModes))
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := Convert_v1_VolumeResourceRequirements_To_core_VolumeResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
                return err
        }
        out.VolumeName = in.VolumeName
        out.StorageClassName = (*string)(unsafe.Pointer(in.StorageClassName))
        out.VolumeMode = (*core.PersistentVolumeMode)(unsafe.Pointer(in.VolumeMode))
        out.DataSource = (*core.TypedLocalObjectReference)(unsafe.Pointer(in.DataSource))
        out.DataSourceRef = (*core.TypedObjectReference)(unsafe.Pointer(in.DataSourceRef))
        out.VolumeAttributesClassName = (*string)(unsafe.Pointer(in.VolumeAttributesClassName))
        return nil
}

// Convert_v1_PersistentVolumeClaimSpec_To_core_PersistentVolumeClaimSpec is an autogenerated conversion function.
func Convert_v1_PersistentVolumeClaimSpec_To_core_PersistentVolumeClaimSpec(in *corev1.PersistentVolumeClaimSpec, out *core.PersistentVolumeClaimSpec, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeClaimSpec_To_core_PersistentVolumeClaimSpec(in, out, s)
}

func autoConvert_core_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(in *core.PersistentVolumeClaimSpec, out *corev1.PersistentVolumeClaimSpec, s conversion.Scope) error {
        out.AccessModes = *(*[]corev1.PersistentVolumeAccessMode)(unsafe.Pointer(&in.AccessModes))
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := Convert_core_VolumeResourceRequirements_To_v1_VolumeResourceRequirements(&in.Resources, &out.Resources, s); err != nil {
                return err
        }
        out.VolumeName = in.VolumeName
        out.StorageClassName = (*string)(unsafe.Pointer(in.StorageClassName))
        out.VolumeMode = (*corev1.PersistentVolumeMode)(unsafe.Pointer(in.VolumeMode))
        out.DataSource = (*corev1.TypedLocalObjectReference)(unsafe.Pointer(in.DataSource))
        out.DataSourceRef = (*corev1.TypedObjectReference)(unsafe.Pointer(in.DataSourceRef))
        out.VolumeAttributesClassName = (*string)(unsafe.Pointer(in.VolumeAttributesClassName))
        return nil
}

// Convert_core_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec is an autogenerated conversion function.
func Convert_core_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(in *core.PersistentVolumeClaimSpec, out *corev1.PersistentVolumeClaimSpec, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(in, out, s)
}

func autoConvert_v1_PersistentVolumeClaimStatus_To_core_PersistentVolumeClaimStatus(in *corev1.PersistentVolumeClaimStatus, out *core.PersistentVolumeClaimStatus, s conversion.Scope) error {
        out.Phase = core.PersistentVolumeClaimPhase(in.Phase)
        out.AccessModes = *(*[]core.PersistentVolumeAccessMode)(unsafe.Pointer(&in.AccessModes))
        out.Capacity = *(*core.ResourceList)(unsafe.Pointer(&in.Capacity))
        out.Conditions = *(*[]core.PersistentVolumeClaimCondition)(unsafe.Pointer(&in.Conditions))
        out.AllocatedResources = *(*core.ResourceList)(unsafe.Pointer(&in.AllocatedResources))
        out.AllocatedResourceStatuses = *(*map[core.ResourceName]core.ClaimResourceStatus)(unsafe.Pointer(&in.AllocatedResourceStatuses))
        out.CurrentVolumeAttributesClassName = (*string)(unsafe.Pointer(in.CurrentVolumeAttributesClassName))
        out.ModifyVolumeStatus = (*core.ModifyVolumeStatus)(unsafe.Pointer(in.ModifyVolumeStatus))
        return nil
}

// Convert_v1_PersistentVolumeClaimStatus_To_core_PersistentVolumeClaimStatus is an autogenerated conversion function.
func Convert_v1_PersistentVolumeClaimStatus_To_core_PersistentVolumeClaimStatus(in *corev1.PersistentVolumeClaimStatus, out *core.PersistentVolumeClaimStatus, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeClaimStatus_To_core_PersistentVolumeClaimStatus(in, out, s)
}

func autoConvert_core_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(in *core.PersistentVolumeClaimStatus, out *corev1.PersistentVolumeClaimStatus, s conversion.Scope) error {
        out.Phase = corev1.PersistentVolumeClaimPhase(in.Phase)
        out.AccessModes = *(*[]corev1.PersistentVolumeAccessMode)(unsafe.Pointer(&in.AccessModes))
        out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
        out.Conditions = *(*[]corev1.PersistentVolumeClaimCondition)(unsafe.Pointer(&in.Conditions))
        out.AllocatedResources = *(*corev1.ResourceList)(unsafe.Pointer(&in.AllocatedResources))
        out.AllocatedResourceStatuses = *(*map[corev1.ResourceName]corev1.ClaimResourceStatus)(unsafe.Pointer(&in.AllocatedResourceStatuses))
        out.CurrentVolumeAttributesClassName = (*string)(unsafe.Pointer(in.CurrentVolumeAttributesClassName))
        out.ModifyVolumeStatus = (*corev1.ModifyVolumeStatus)(unsafe.Pointer(in.ModifyVolumeStatus))
        return nil
}

// Convert_core_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus is an autogenerated conversion function.
func Convert_core_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(in *core.PersistentVolumeClaimStatus, out *corev1.PersistentVolumeClaimStatus, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeClaimStatus_To_v1_PersistentVolumeClaimStatus(in, out, s)
}

func autoConvert_v1_PersistentVolumeClaimTemplate_To_core_PersistentVolumeClaimTemplate(in *corev1.PersistentVolumeClaimTemplate, out *core.PersistentVolumeClaimTemplate, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_PersistentVolumeClaimSpec_To_core_PersistentVolumeClaimSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_PersistentVolumeClaimTemplate_To_core_PersistentVolumeClaimTemplate is an autogenerated conversion function.
func Convert_v1_PersistentVolumeClaimTemplate_To_core_PersistentVolumeClaimTemplate(in *corev1.PersistentVolumeClaimTemplate, out *core.PersistentVolumeClaimTemplate, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeClaimTemplate_To_core_PersistentVolumeClaimTemplate(in, out, s)
}

func autoConvert_core_PersistentVolumeClaimTemplate_To_v1_PersistentVolumeClaimTemplate(in *core.PersistentVolumeClaimTemplate, out *corev1.PersistentVolumeClaimTemplate, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_PersistentVolumeClaimSpec_To_v1_PersistentVolumeClaimSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_PersistentVolumeClaimTemplate_To_v1_PersistentVolumeClaimTemplate is an autogenerated conversion function.
func Convert_core_PersistentVolumeClaimTemplate_To_v1_PersistentVolumeClaimTemplate(in *core.PersistentVolumeClaimTemplate, out *corev1.PersistentVolumeClaimTemplate, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeClaimTemplate_To_v1_PersistentVolumeClaimTemplate(in, out, s)
}

func autoConvert_v1_PersistentVolumeClaimVolumeSource_To_core_PersistentVolumeClaimVolumeSource(in *corev1.PersistentVolumeClaimVolumeSource, out *core.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
        out.ClaimName = in.ClaimName
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_PersistentVolumeClaimVolumeSource_To_core_PersistentVolumeClaimVolumeSource is an autogenerated conversion function.
func Convert_v1_PersistentVolumeClaimVolumeSource_To_core_PersistentVolumeClaimVolumeSource(in *corev1.PersistentVolumeClaimVolumeSource, out *core.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeClaimVolumeSource_To_core_PersistentVolumeClaimVolumeSource(in, out, s)
}

func autoConvert_core_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in *core.PersistentVolumeClaimVolumeSource, out *corev1.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
        out.ClaimName = in.ClaimName
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource is an autogenerated conversion function.
func Convert_core_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in *core.PersistentVolumeClaimVolumeSource, out *corev1.PersistentVolumeClaimVolumeSource, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeClaimVolumeSource_To_v1_PersistentVolumeClaimVolumeSource(in, out, s)
}

func autoConvert_v1_PersistentVolumeList_To_core_PersistentVolumeList(in *corev1.PersistentVolumeList, out *core.PersistentVolumeList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.PersistentVolume, len(*in))
                for i := range *in {
                        if err := Convert_v1_PersistentVolume_To_core_PersistentVolume(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_PersistentVolumeList_To_core_PersistentVolumeList is an autogenerated conversion function.
func Convert_v1_PersistentVolumeList_To_core_PersistentVolumeList(in *corev1.PersistentVolumeList, out *core.PersistentVolumeList, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeList_To_core_PersistentVolumeList(in, out, s)
}

func autoConvert_core_PersistentVolumeList_To_v1_PersistentVolumeList(in *core.PersistentVolumeList, out *corev1.PersistentVolumeList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]corev1.PersistentVolume, len(*in))
                for i := range *in {
                        if err := Convert_core_PersistentVolume_To_v1_PersistentVolume(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_PersistentVolumeList_To_v1_PersistentVolumeList is an autogenerated conversion function.
func Convert_core_PersistentVolumeList_To_v1_PersistentVolumeList(in *core.PersistentVolumeList, out *corev1.PersistentVolumeList, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeList_To_v1_PersistentVolumeList(in, out, s)
}

func autoConvert_v1_PersistentVolumeSource_To_core_PersistentVolumeSource(in *corev1.PersistentVolumeSource, out *core.PersistentVolumeSource, s conversion.Scope) error {
        out.GCEPersistentDisk = (*core.GCEPersistentDiskVolumeSource)(unsafe.Pointer(in.GCEPersistentDisk))
        out.AWSElasticBlockStore = (*core.AWSElasticBlockStoreVolumeSource)(unsafe.Pointer(in.AWSElasticBlockStore))
        out.HostPath = (*core.HostPathVolumeSource)(unsafe.Pointer(in.HostPath))
        out.Glusterfs = (*core.GlusterfsPersistentVolumeSource)(unsafe.Pointer(in.Glusterfs))
        out.NFS = (*core.NFSVolumeSource)(unsafe.Pointer(in.NFS))
        out.RBD = (*core.RBDPersistentVolumeSource)(unsafe.Pointer(in.RBD))
        out.ISCSI = (*core.ISCSIPersistentVolumeSource)(unsafe.Pointer(in.ISCSI))
        out.Cinder = (*core.CinderPersistentVolumeSource)(unsafe.Pointer(in.Cinder))
        out.CephFS = (*core.CephFSPersistentVolumeSource)(unsafe.Pointer(in.CephFS))
        out.FC = (*core.FCVolumeSource)(unsafe.Pointer(in.FC))
        out.Flocker = (*core.FlockerVolumeSource)(unsafe.Pointer(in.Flocker))
        out.FlexVolume = (*core.FlexPersistentVolumeSource)(unsafe.Pointer(in.FlexVolume))
        out.AzureFile = (*core.AzureFilePersistentVolumeSource)(unsafe.Pointer(in.AzureFile))
        out.VsphereVolume = (*core.VsphereVirtualDiskVolumeSource)(unsafe.Pointer(in.VsphereVolume))
        out.Quobyte = (*core.QuobyteVolumeSource)(unsafe.Pointer(in.Quobyte))
        out.AzureDisk = (*core.AzureDiskVolumeSource)(unsafe.Pointer(in.AzureDisk))
        out.PhotonPersistentDisk = (*core.PhotonPersistentDiskVolumeSource)(unsafe.Pointer(in.PhotonPersistentDisk))
        out.PortworxVolume = (*core.PortworxVolumeSource)(unsafe.Pointer(in.PortworxVolume))
        out.ScaleIO = (*core.ScaleIOPersistentVolumeSource)(unsafe.Pointer(in.ScaleIO))
        out.Local = (*core.LocalVolumeSource)(unsafe.Pointer(in.Local))
        out.StorageOS = (*core.StorageOSPersistentVolumeSource)(unsafe.Pointer(in.StorageOS))
        out.CSI = (*core.CSIPersistentVolumeSource)(unsafe.Pointer(in.CSI))
        return nil
}

// Convert_v1_PersistentVolumeSource_To_core_PersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_PersistentVolumeSource_To_core_PersistentVolumeSource(in *corev1.PersistentVolumeSource, out *core.PersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeSource_To_core_PersistentVolumeSource(in, out, s)
}

func autoConvert_core_PersistentVolumeSource_To_v1_PersistentVolumeSource(in *core.PersistentVolumeSource, out *corev1.PersistentVolumeSource, s conversion.Scope) error {
        out.GCEPersistentDisk = (*corev1.GCEPersistentDiskVolumeSource)(unsafe.Pointer(in.GCEPersistentDisk))
        out.AWSElasticBlockStore = (*corev1.AWSElasticBlockStoreVolumeSource)(unsafe.Pointer(in.AWSElasticBlockStore))
        out.HostPath = (*corev1.HostPathVolumeSource)(unsafe.Pointer(in.HostPath))
        out.Glusterfs = (*corev1.GlusterfsPersistentVolumeSource)(unsafe.Pointer(in.Glusterfs))
        out.NFS = (*corev1.NFSVolumeSource)(unsafe.Pointer(in.NFS))
        out.RBD = (*corev1.RBDPersistentVolumeSource)(unsafe.Pointer(in.RBD))
        out.Quobyte = (*corev1.QuobyteVolumeSource)(unsafe.Pointer(in.Quobyte))
        out.ISCSI = (*corev1.ISCSIPersistentVolumeSource)(unsafe.Pointer(in.ISCSI))
        out.FlexVolume = (*corev1.FlexPersistentVolumeSource)(unsafe.Pointer(in.FlexVolume))
        out.Cinder = (*corev1.CinderPersistentVolumeSource)(unsafe.Pointer(in.Cinder))
        out.CephFS = (*corev1.CephFSPersistentVolumeSource)(unsafe.Pointer(in.CephFS))
        out.FC = (*corev1.FCVolumeSource)(unsafe.Pointer(in.FC))
        out.Flocker = (*corev1.FlockerVolumeSource)(unsafe.Pointer(in.Flocker))
        out.AzureFile = (*corev1.AzureFilePersistentVolumeSource)(unsafe.Pointer(in.AzureFile))
        out.VsphereVolume = (*corev1.VsphereVirtualDiskVolumeSource)(unsafe.Pointer(in.VsphereVolume))
        out.AzureDisk = (*corev1.AzureDiskVolumeSource)(unsafe.Pointer(in.AzureDisk))
        out.PhotonPersistentDisk = (*corev1.PhotonPersistentDiskVolumeSource)(unsafe.Pointer(in.PhotonPersistentDisk))
        out.PortworxVolume = (*corev1.PortworxVolumeSource)(unsafe.Pointer(in.PortworxVolume))
        out.ScaleIO = (*corev1.ScaleIOPersistentVolumeSource)(unsafe.Pointer(in.ScaleIO))
        out.Local = (*corev1.LocalVolumeSource)(unsafe.Pointer(in.Local))
        out.StorageOS = (*corev1.StorageOSPersistentVolumeSource)(unsafe.Pointer(in.StorageOS))
        out.CSI = (*corev1.CSIPersistentVolumeSource)(unsafe.Pointer(in.CSI))
        return nil
}

// Convert_core_PersistentVolumeSource_To_v1_PersistentVolumeSource is an autogenerated conversion function.
func Convert_core_PersistentVolumeSource_To_v1_PersistentVolumeSource(in *core.PersistentVolumeSource, out *corev1.PersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeSource_To_v1_PersistentVolumeSource(in, out, s)
}

func autoConvert_v1_PersistentVolumeSpec_To_core_PersistentVolumeSpec(in *corev1.PersistentVolumeSpec, out *core.PersistentVolumeSpec, s conversion.Scope) error {
        out.Capacity = *(*core.ResourceList)(unsafe.Pointer(&in.Capacity))
        if err := Convert_v1_PersistentVolumeSource_To_core_PersistentVolumeSource(&in.PersistentVolumeSource, &out.PersistentVolumeSource, s); err != nil {
                return err
        }
        out.AccessModes = *(*[]core.PersistentVolumeAccessMode)(unsafe.Pointer(&in.AccessModes))
        out.ClaimRef = (*core.ObjectReference)(unsafe.Pointer(in.ClaimRef))
        out.PersistentVolumeReclaimPolicy = core.PersistentVolumeReclaimPolicy(in.PersistentVolumeReclaimPolicy)
        out.StorageClassName = in.StorageClassName
        out.MountOptions = *(*[]string)(unsafe.Pointer(&in.MountOptions))
        out.VolumeMode = (*core.PersistentVolumeMode)(unsafe.Pointer(in.VolumeMode))
        out.NodeAffinity = (*core.VolumeNodeAffinity)(unsafe.Pointer(in.NodeAffinity))
        out.VolumeAttributesClassName = (*string)(unsafe.Pointer(in.VolumeAttributesClassName))
        return nil
}

func autoConvert_core_PersistentVolumeSpec_To_v1_PersistentVolumeSpec(in *core.PersistentVolumeSpec, out *corev1.PersistentVolumeSpec, s conversion.Scope) error {
        out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
        if err := Convert_core_PersistentVolumeSource_To_v1_PersistentVolumeSource(&in.PersistentVolumeSource, &out.PersistentVolumeSource, s); err != nil {
                return err
        }
        out.AccessModes = *(*[]corev1.PersistentVolumeAccessMode)(unsafe.Pointer(&in.AccessModes))
        out.ClaimRef = (*corev1.ObjectReference)(unsafe.Pointer(in.ClaimRef))
        out.PersistentVolumeReclaimPolicy = corev1.PersistentVolumeReclaimPolicy(in.PersistentVolumeReclaimPolicy)
        out.StorageClassName = in.StorageClassName
        out.MountOptions = *(*[]string)(unsafe.Pointer(&in.MountOptions))
        out.VolumeMode = (*corev1.PersistentVolumeMode)(unsafe.Pointer(in.VolumeMode))
        out.NodeAffinity = (*corev1.VolumeNodeAffinity)(unsafe.Pointer(in.NodeAffinity))
        out.VolumeAttributesClassName = (*string)(unsafe.Pointer(in.VolumeAttributesClassName))
        return nil
}

func autoConvert_v1_PersistentVolumeStatus_To_core_PersistentVolumeStatus(in *corev1.PersistentVolumeStatus, out *core.PersistentVolumeStatus, s conversion.Scope) error {
        out.Phase = core.PersistentVolumePhase(in.Phase)
        out.Message = in.Message
        out.Reason = in.Reason
        out.LastPhaseTransitionTime = (*metav1.Time)(unsafe.Pointer(in.LastPhaseTransitionTime))
        return nil
}

// Convert_v1_PersistentVolumeStatus_To_core_PersistentVolumeStatus is an autogenerated conversion function.
func Convert_v1_PersistentVolumeStatus_To_core_PersistentVolumeStatus(in *corev1.PersistentVolumeStatus, out *core.PersistentVolumeStatus, s conversion.Scope) error {
        return autoConvert_v1_PersistentVolumeStatus_To_core_PersistentVolumeStatus(in, out, s)
}

func autoConvert_core_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in *core.PersistentVolumeStatus, out *corev1.PersistentVolumeStatus, s conversion.Scope) error {
        out.Phase = corev1.PersistentVolumePhase(in.Phase)
        out.Message = in.Message
        out.Reason = in.Reason
        out.LastPhaseTransitionTime = (*metav1.Time)(unsafe.Pointer(in.LastPhaseTransitionTime))
        return nil
}

// Convert_core_PersistentVolumeStatus_To_v1_PersistentVolumeStatus is an autogenerated conversion function.
func Convert_core_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in *core.PersistentVolumeStatus, out *corev1.PersistentVolumeStatus, s conversion.Scope) error {
        return autoConvert_core_PersistentVolumeStatus_To_v1_PersistentVolumeStatus(in, out, s)
}

func autoConvert_v1_PhotonPersistentDiskVolumeSource_To_core_PhotonPersistentDiskVolumeSource(in *corev1.PhotonPersistentDiskVolumeSource, out *core.PhotonPersistentDiskVolumeSource, s conversion.Scope) error {
        out.PdID = in.PdID
        out.FSType = in.FSType
        return nil
}

// Convert_v1_PhotonPersistentDiskVolumeSource_To_core_PhotonPersistentDiskVolumeSource is an autogenerated conversion function.
func Convert_v1_PhotonPersistentDiskVolumeSource_To_core_PhotonPersistentDiskVolumeSource(in *corev1.PhotonPersistentDiskVolumeSource, out *core.PhotonPersistentDiskVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_PhotonPersistentDiskVolumeSource_To_core_PhotonPersistentDiskVolumeSource(in, out, s)
}

func autoConvert_core_PhotonPersistentDiskVolumeSource_To_v1_PhotonPersistentDiskVolumeSource(in *core.PhotonPersistentDiskVolumeSource, out *corev1.PhotonPersistentDiskVolumeSource, s conversion.Scope) error {
        out.PdID = in.PdID
        out.FSType = in.FSType
        return nil
}

// Convert_core_PhotonPersistentDiskVolumeSource_To_v1_PhotonPersistentDiskVolumeSource is an autogenerated conversion function.
func Convert_core_PhotonPersistentDiskVolumeSource_To_v1_PhotonPersistentDiskVolumeSource(in *core.PhotonPersistentDiskVolumeSource, out *corev1.PhotonPersistentDiskVolumeSource, s conversion.Scope) error {
        return autoConvert_core_PhotonPersistentDiskVolumeSource_To_v1_PhotonPersistentDiskVolumeSource(in, out, s)
}

func autoConvert_v1_Pod_To_core_Pod(in *corev1.Pod, out *core.Pod, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_PodSpec_To_core_PodSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_PodStatus_To_core_PodStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_core_Pod_To_v1_Pod(in *core.Pod, out *corev1.Pod, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_PodSpec_To_v1_PodSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_core_PodStatus_To_v1_PodStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_PodAffinity_To_core_PodAffinity(in *corev1.PodAffinity, out *core.PodAffinity, s conversion.Scope) error {
        out.RequiredDuringSchedulingIgnoredDuringExecution = *(*[]core.PodAffinityTerm)(unsafe.Pointer(&in.RequiredDuringSchedulingIgnoredDuringExecution))
        out.PreferredDuringSchedulingIgnoredDuringExecution = *(*[]core.WeightedPodAffinityTerm)(unsafe.Pointer(&in.PreferredDuringSchedulingIgnoredDuringExecution))
        return nil
}

// Convert_v1_PodAffinity_To_core_PodAffinity is an autogenerated conversion function.
func Convert_v1_PodAffinity_To_core_PodAffinity(in *corev1.PodAffinity, out *core.PodAffinity, s conversion.Scope) error {
        return autoConvert_v1_PodAffinity_To_core_PodAffinity(in, out, s)
}

func autoConvert_core_PodAffinity_To_v1_PodAffinity(in *core.PodAffinity, out *corev1.PodAffinity, s conversion.Scope) error {
        out.RequiredDuringSchedulingIgnoredDuringExecution = *(*[]corev1.PodAffinityTerm)(unsafe.Pointer(&in.RequiredDuringSchedulingIgnoredDuringExecution))
        out.PreferredDuringSchedulingIgnoredDuringExecution = *(*[]corev1.WeightedPodAffinityTerm)(unsafe.Pointer(&in.PreferredDuringSchedulingIgnoredDuringExecution))
        return nil
}

// Convert_core_PodAffinity_To_v1_PodAffinity is an autogenerated conversion function.
func Convert_core_PodAffinity_To_v1_PodAffinity(in *core.PodAffinity, out *corev1.PodAffinity, s conversion.Scope) error {
        return autoConvert_core_PodAffinity_To_v1_PodAffinity(in, out, s)
}

func autoConvert_v1_PodAffinityTerm_To_core_PodAffinityTerm(in *corev1.PodAffinityTerm, out *core.PodAffinityTerm, s conversion.Scope) error {
        out.LabelSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.LabelSelector))
        out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces))
        out.TopologyKey = in.TopologyKey
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.MatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MatchLabelKeys))
        out.MismatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MismatchLabelKeys))
        return nil
}

// Convert_v1_PodAffinityTerm_To_core_PodAffinityTerm is an autogenerated conversion function.
func Convert_v1_PodAffinityTerm_To_core_PodAffinityTerm(in *corev1.PodAffinityTerm, out *core.PodAffinityTerm, s conversion.Scope) error {
        return autoConvert_v1_PodAffinityTerm_To_core_PodAffinityTerm(in, out, s)
}

func autoConvert_core_PodAffinityTerm_To_v1_PodAffinityTerm(in *core.PodAffinityTerm, out *corev1.PodAffinityTerm, s conversion.Scope) error {
        out.LabelSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.LabelSelector))
        out.Namespaces = *(*[]string)(unsafe.Pointer(&in.Namespaces))
        out.TopologyKey = in.TopologyKey
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        out.MatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MatchLabelKeys))
        out.MismatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MismatchLabelKeys))
        return nil
}

// Convert_core_PodAffinityTerm_To_v1_PodAffinityTerm is an autogenerated conversion function.
func Convert_core_PodAffinityTerm_To_v1_PodAffinityTerm(in *core.PodAffinityTerm, out *corev1.PodAffinityTerm, s conversion.Scope) error {
        return autoConvert_core_PodAffinityTerm_To_v1_PodAffinityTerm(in, out, s)
}

func autoConvert_v1_PodAntiAffinity_To_core_PodAntiAffinity(in *corev1.PodAntiAffinity, out *core.PodAntiAffinity, s conversion.Scope) error {
        out.RequiredDuringSchedulingIgnoredDuringExecution = *(*[]core.PodAffinityTerm)(unsafe.Pointer(&in.RequiredDuringSchedulingIgnoredDuringExecution))
        out.PreferredDuringSchedulingIgnoredDuringExecution = *(*[]core.WeightedPodAffinityTerm)(unsafe.Pointer(&in.PreferredDuringSchedulingIgnoredDuringExecution))
        return nil
}

// Convert_v1_PodAntiAffinity_To_core_PodAntiAffinity is an autogenerated conversion function.
func Convert_v1_PodAntiAffinity_To_core_PodAntiAffinity(in *corev1.PodAntiAffinity, out *core.PodAntiAffinity, s conversion.Scope) error {
        return autoConvert_v1_PodAntiAffinity_To_core_PodAntiAffinity(in, out, s)
}

func autoConvert_core_PodAntiAffinity_To_v1_PodAntiAffinity(in *core.PodAntiAffinity, out *corev1.PodAntiAffinity, s conversion.Scope) error {
        out.RequiredDuringSchedulingIgnoredDuringExecution = *(*[]corev1.PodAffinityTerm)(unsafe.Pointer(&in.RequiredDuringSchedulingIgnoredDuringExecution))
        out.PreferredDuringSchedulingIgnoredDuringExecution = *(*[]corev1.WeightedPodAffinityTerm)(unsafe.Pointer(&in.PreferredDuringSchedulingIgnoredDuringExecution))
        return nil
}

// Convert_core_PodAntiAffinity_To_v1_PodAntiAffinity is an autogenerated conversion function.
func Convert_core_PodAntiAffinity_To_v1_PodAntiAffinity(in *core.PodAntiAffinity, out *corev1.PodAntiAffinity, s conversion.Scope) error {
        return autoConvert_core_PodAntiAffinity_To_v1_PodAntiAffinity(in, out, s)
}

func autoConvert_v1_PodAttachOptions_To_core_PodAttachOptions(in *corev1.PodAttachOptions, out *core.PodAttachOptions, s conversion.Scope) error {
        out.Stdin = in.Stdin
        out.Stdout = in.Stdout
        out.Stderr = in.Stderr
        out.TTY = in.TTY
        out.Container = in.Container
        return nil
}

// Convert_v1_PodAttachOptions_To_core_PodAttachOptions is an autogenerated conversion function.
func Convert_v1_PodAttachOptions_To_core_PodAttachOptions(in *corev1.PodAttachOptions, out *core.PodAttachOptions, s conversion.Scope) error {
        return autoConvert_v1_PodAttachOptions_To_core_PodAttachOptions(in, out, s)
}

func autoConvert_core_PodAttachOptions_To_v1_PodAttachOptions(in *core.PodAttachOptions, out *corev1.PodAttachOptions, s conversion.Scope) error {
        out.Stdin = in.Stdin
        out.Stdout = in.Stdout
        out.Stderr = in.Stderr
        out.TTY = in.TTY
        out.Container = in.Container
        return nil
}

// Convert_core_PodAttachOptions_To_v1_PodAttachOptions is an autogenerated conversion function.
func Convert_core_PodAttachOptions_To_v1_PodAttachOptions(in *core.PodAttachOptions, out *corev1.PodAttachOptions, s conversion.Scope) error {
        return autoConvert_core_PodAttachOptions_To_v1_PodAttachOptions(in, out, s)
}

func autoConvert_url_Values_To_v1_PodAttachOptions(in *url.Values, out *corev1.PodAttachOptions, s conversion.Scope) error {
        // WARNING: Field TypeMeta does not have json tag, skipping.

        if values, ok := map[string][]string(*in)["stdin"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Stdin, s); err != nil {
                        return err
                }
        } else {
                out.Stdin = false
        }
        if values, ok := map[string][]string(*in)["stdout"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Stdout, s); err != nil {
                        return err
                }
        } else {
                out.Stdout = false
        }
        if values, ok := map[string][]string(*in)["stderr"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Stderr, s); err != nil {
                        return err
                }
        } else {
                out.Stderr = false
        }
        if values, ok := map[string][]string(*in)["tty"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.TTY, s); err != nil {
                        return err
                }
        } else {
                out.TTY = false
        }
        if values, ok := map[string][]string(*in)["container"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_string(&values, &out.Container, s); err != nil {
                        return err
                }
        } else {
                out.Container = ""
        }
        return nil
}

// Convert_url_Values_To_v1_PodAttachOptions is an autogenerated conversion function.
func Convert_url_Values_To_v1_PodAttachOptions(in *url.Values, out *corev1.PodAttachOptions, s conversion.Scope) error {
        return autoConvert_url_Values_To_v1_PodAttachOptions(in, out, s)
}

func autoConvert_v1_PodCertificateProjection_To_core_PodCertificateProjection(in *corev1.PodCertificateProjection, out *core.PodCertificateProjection, s conversion.Scope) error {
        out.SignerName = in.SignerName
        out.KeyType = in.KeyType
        out.MaxExpirationSeconds = (*int32)(unsafe.Pointer(in.MaxExpirationSeconds))
        out.CredentialBundlePath = in.CredentialBundlePath
        out.KeyPath = in.KeyPath
        out.CertificateChainPath = in.CertificateChainPath
        return nil
}

// Convert_v1_PodCertificateProjection_To_core_PodCertificateProjection is an autogenerated conversion function.
func Convert_v1_PodCertificateProjection_To_core_PodCertificateProjection(in *corev1.PodCertificateProjection, out *core.PodCertificateProjection, s conversion.Scope) error {
        return autoConvert_v1_PodCertificateProjection_To_core_PodCertificateProjection(in, out, s)
}

func autoConvert_core_PodCertificateProjection_To_v1_PodCertificateProjection(in *core.PodCertificateProjection, out *corev1.PodCertificateProjection, s conversion.Scope) error {
        out.SignerName = in.SignerName
        out.KeyType = in.KeyType
        out.MaxExpirationSeconds = (*int32)(unsafe.Pointer(in.MaxExpirationSeconds))
        out.CredentialBundlePath = in.CredentialBundlePath
        out.KeyPath = in.KeyPath
        out.CertificateChainPath = in.CertificateChainPath
        return nil
}

// Convert_core_PodCertificateProjection_To_v1_PodCertificateProjection is an autogenerated conversion function.
func Convert_core_PodCertificateProjection_To_v1_PodCertificateProjection(in *core.PodCertificateProjection, out *corev1.PodCertificateProjection, s conversion.Scope) error {
        return autoConvert_core_PodCertificateProjection_To_v1_PodCertificateProjection(in, out, s)
}

func autoConvert_v1_PodCondition_To_core_PodCondition(in *corev1.PodCondition, out *core.PodCondition, s conversion.Scope) error {
        out.Type = core.PodConditionType(in.Type)
        out.ObservedGeneration = in.ObservedGeneration
        out.Status = core.ConditionStatus(in.Status)
        out.LastProbeTime = in.LastProbeTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_PodCondition_To_core_PodCondition is an autogenerated conversion function.
func Convert_v1_PodCondition_To_core_PodCondition(in *corev1.PodCondition, out *core.PodCondition, s conversion.Scope) error {
        return autoConvert_v1_PodCondition_To_core_PodCondition(in, out, s)
}

func autoConvert_core_PodCondition_To_v1_PodCondition(in *core.PodCondition, out *corev1.PodCondition, s conversion.Scope) error {
        out.Type = corev1.PodConditionType(in.Type)
        out.ObservedGeneration = in.ObservedGeneration
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastProbeTime = in.LastProbeTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_core_PodCondition_To_v1_PodCondition is an autogenerated conversion function.
func Convert_core_PodCondition_To_v1_PodCondition(in *core.PodCondition, out *corev1.PodCondition, s conversion.Scope) error {
        return autoConvert_core_PodCondition_To_v1_PodCondition(in, out, s)
}

func autoConvert_v1_PodDNSConfig_To_core_PodDNSConfig(in *corev1.PodDNSConfig, out *core.PodDNSConfig, s conversion.Scope) error {
        out.Nameservers = *(*[]string)(unsafe.Pointer(&in.Nameservers))
        out.Searches = *(*[]string)(unsafe.Pointer(&in.Searches))
        out.Options = *(*[]core.PodDNSConfigOption)(unsafe.Pointer(&in.Options))
        return nil
}

// Convert_v1_PodDNSConfig_To_core_PodDNSConfig is an autogenerated conversion function.
func Convert_v1_PodDNSConfig_To_core_PodDNSConfig(in *corev1.PodDNSConfig, out *core.PodDNSConfig, s conversion.Scope) error {
        return autoConvert_v1_PodDNSConfig_To_core_PodDNSConfig(in, out, s)
}

func autoConvert_core_PodDNSConfig_To_v1_PodDNSConfig(in *core.PodDNSConfig, out *corev1.PodDNSConfig, s conversion.Scope) error {
        out.Nameservers = *(*[]string)(unsafe.Pointer(&in.Nameservers))
        out.Searches = *(*[]string)(unsafe.Pointer(&in.Searches))
        out.Options = *(*[]corev1.PodDNSConfigOption)(unsafe.Pointer(&in.Options))
        return nil
}

// Convert_core_PodDNSConfig_To_v1_PodDNSConfig is an autogenerated conversion function.
func Convert_core_PodDNSConfig_To_v1_PodDNSConfig(in *core.PodDNSConfig, out *corev1.PodDNSConfig, s conversion.Scope) error {
        return autoConvert_core_PodDNSConfig_To_v1_PodDNSConfig(in, out, s)
}

func autoConvert_v1_PodDNSConfigOption_To_core_PodDNSConfigOption(in *corev1.PodDNSConfigOption, out *core.PodDNSConfigOption, s conversion.Scope) error {
        out.Name = in.Name
        out.Value = (*string)(unsafe.Pointer(in.Value))
        return nil
}

// Convert_v1_PodDNSConfigOption_To_core_PodDNSConfigOption is an autogenerated conversion function.
func Convert_v1_PodDNSConfigOption_To_core_PodDNSConfigOption(in *corev1.PodDNSConfigOption, out *core.PodDNSConfigOption, s conversion.Scope) error {
        return autoConvert_v1_PodDNSConfigOption_To_core_PodDNSConfigOption(in, out, s)
}

func autoConvert_core_PodDNSConfigOption_To_v1_PodDNSConfigOption(in *core.PodDNSConfigOption, out *corev1.PodDNSConfigOption, s conversion.Scope) error {
        out.Name = in.Name
        out.Value = (*string)(unsafe.Pointer(in.Value))
        return nil
}

// Convert_core_PodDNSConfigOption_To_v1_PodDNSConfigOption is an autogenerated conversion function.
func Convert_core_PodDNSConfigOption_To_v1_PodDNSConfigOption(in *core.PodDNSConfigOption, out *corev1.PodDNSConfigOption, s conversion.Scope) error {
        return autoConvert_core_PodDNSConfigOption_To_v1_PodDNSConfigOption(in, out, s)
}

func autoConvert_v1_PodExecOptions_To_core_PodExecOptions(in *corev1.PodExecOptions, out *core.PodExecOptions, s conversion.Scope) error {
        out.Stdin = in.Stdin
        out.Stdout = in.Stdout
        out.Stderr = in.Stderr
        out.TTY = in.TTY
        out.Container = in.Container
        out.Command = *(*[]string)(unsafe.Pointer(&in.Command))
        return nil
}

// Convert_v1_PodExecOptions_To_core_PodExecOptions is an autogenerated conversion function.
func Convert_v1_PodExecOptions_To_core_PodExecOptions(in *corev1.PodExecOptions, out *core.PodExecOptions, s conversion.Scope) error {
        return autoConvert_v1_PodExecOptions_To_core_PodExecOptions(in, out, s)
}

func autoConvert_core_PodExecOptions_To_v1_PodExecOptions(in *core.PodExecOptions, out *corev1.PodExecOptions, s conversion.Scope) error {
        out.Stdin = in.Stdin
        out.Stdout = in.Stdout
        out.Stderr = in.Stderr
        out.TTY = in.TTY
        out.Container = in.Container
        out.Command = *(*[]string)(unsafe.Pointer(&in.Command))
        return nil
}

// Convert_core_PodExecOptions_To_v1_PodExecOptions is an autogenerated conversion function.
func Convert_core_PodExecOptions_To_v1_PodExecOptions(in *core.PodExecOptions, out *corev1.PodExecOptions, s conversion.Scope) error {
        return autoConvert_core_PodExecOptions_To_v1_PodExecOptions(in, out, s)
}

func autoConvert_url_Values_To_v1_PodExecOptions(in *url.Values, out *corev1.PodExecOptions, s conversion.Scope) error {
        // WARNING: Field TypeMeta does not have json tag, skipping.

        if values, ok := map[string][]string(*in)["stdin"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Stdin, s); err != nil {
                        return err
                }
        } else {
                out.Stdin = false
        }
        if values, ok := map[string][]string(*in)["stdout"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Stdout, s); err != nil {
                        return err
                }
        } else {
                out.Stdout = false
        }
        if values, ok := map[string][]string(*in)["stderr"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Stderr, s); err != nil {
                        return err
                }
        } else {
                out.Stderr = false
        }
        if values, ok := map[string][]string(*in)["tty"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.TTY, s); err != nil {
                        return err
                }
        } else {
                out.TTY = false
        }
        if values, ok := map[string][]string(*in)["container"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_string(&values, &out.Container, s); err != nil {
                        return err
                }
        } else {
                out.Container = ""
        }
        if values, ok := map[string][]string(*in)["command"]; ok && len(values) > 0 {
                out.Command = *(*[]string)(unsafe.Pointer(&values))
        } else {
                out.Command = nil
        }
        return nil
}

// Convert_url_Values_To_v1_PodExecOptions is an autogenerated conversion function.
func Convert_url_Values_To_v1_PodExecOptions(in *url.Values, out *corev1.PodExecOptions, s conversion.Scope) error {
        return autoConvert_url_Values_To_v1_PodExecOptions(in, out, s)
}

func autoConvert_v1_PodExtendedResourceClaimStatus_To_core_PodExtendedResourceClaimStatus(in *corev1.PodExtendedResourceClaimStatus, out *core.PodExtendedResourceClaimStatus, s conversion.Scope) error {
        out.RequestMappings = *(*[]core.ContainerExtendedResourceRequest)(unsafe.Pointer(&in.RequestMappings))
        out.ResourceClaimName = in.ResourceClaimName
        return nil
}

// Convert_v1_PodExtendedResourceClaimStatus_To_core_PodExtendedResourceClaimStatus is an autogenerated conversion function.
func Convert_v1_PodExtendedResourceClaimStatus_To_core_PodExtendedResourceClaimStatus(in *corev1.PodExtendedResourceClaimStatus, out *core.PodExtendedResourceClaimStatus, s conversion.Scope) error {
        return autoConvert_v1_PodExtendedResourceClaimStatus_To_core_PodExtendedResourceClaimStatus(in, out, s)
}

func autoConvert_core_PodExtendedResourceClaimStatus_To_v1_PodExtendedResourceClaimStatus(in *core.PodExtendedResourceClaimStatus, out *corev1.PodExtendedResourceClaimStatus, s conversion.Scope) error {
        out.RequestMappings = *(*[]corev1.ContainerExtendedResourceRequest)(unsafe.Pointer(&in.RequestMappings))
        out.ResourceClaimName = in.ResourceClaimName
        return nil
}

// Convert_core_PodExtendedResourceClaimStatus_To_v1_PodExtendedResourceClaimStatus is an autogenerated conversion function.
func Convert_core_PodExtendedResourceClaimStatus_To_v1_PodExtendedResourceClaimStatus(in *core.PodExtendedResourceClaimStatus, out *corev1.PodExtendedResourceClaimStatus, s conversion.Scope) error {
        return autoConvert_core_PodExtendedResourceClaimStatus_To_v1_PodExtendedResourceClaimStatus(in, out, s)
}

func autoConvert_v1_PodIP_To_core_PodIP(in *corev1.PodIP, out *core.PodIP, s conversion.Scope) error {
        out.IP = in.IP
        return nil
}

// Convert_v1_PodIP_To_core_PodIP is an autogenerated conversion function.
func Convert_v1_PodIP_To_core_PodIP(in *corev1.PodIP, out *core.PodIP, s conversion.Scope) error {
        return autoConvert_v1_PodIP_To_core_PodIP(in, out, s)
}

func autoConvert_core_PodIP_To_v1_PodIP(in *core.PodIP, out *corev1.PodIP, s conversion.Scope) error {
        out.IP = in.IP
        return nil
}

// Convert_core_PodIP_To_v1_PodIP is an autogenerated conversion function.
func Convert_core_PodIP_To_v1_PodIP(in *core.PodIP, out *corev1.PodIP, s conversion.Scope) error {
        return autoConvert_core_PodIP_To_v1_PodIP(in, out, s)
}

func autoConvert_v1_PodList_To_core_PodList(in *corev1.PodList, out *core.PodList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.Pod, len(*in))
                for i := range *in {
                        if err := Convert_v1_Pod_To_core_Pod(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_PodList_To_core_PodList is an autogenerated conversion function.
func Convert_v1_PodList_To_core_PodList(in *corev1.PodList, out *core.PodList, s conversion.Scope) error {
        return autoConvert_v1_PodList_To_core_PodList(in, out, s)
}

func autoConvert_core_PodList_To_v1_PodList(in *core.PodList, out *corev1.PodList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]corev1.Pod, len(*in))
                for i := range *in {
                        if err := Convert_core_Pod_To_v1_Pod(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_PodList_To_v1_PodList is an autogenerated conversion function.
func Convert_core_PodList_To_v1_PodList(in *core.PodList, out *corev1.PodList, s conversion.Scope) error {
        return autoConvert_core_PodList_To_v1_PodList(in, out, s)
}

func autoConvert_v1_PodLogOptions_To_core_PodLogOptions(in *corev1.PodLogOptions, out *core.PodLogOptions, s conversion.Scope) error {
        out.Container = in.Container
        out.Follow = in.Follow
        out.Previous = in.Previous
        out.SinceSeconds = (*int64)(unsafe.Pointer(in.SinceSeconds))
        out.SinceTime = (*metav1.Time)(unsafe.Pointer(in.SinceTime))
        out.Timestamps = in.Timestamps
        out.TailLines = (*int64)(unsafe.Pointer(in.TailLines))
        out.LimitBytes = (*int64)(unsafe.Pointer(in.LimitBytes))
        out.InsecureSkipTLSVerifyBackend = in.InsecureSkipTLSVerifyBackend
        out.Stream = (*string)(unsafe.Pointer(in.Stream))
        return nil
}

// Convert_v1_PodLogOptions_To_core_PodLogOptions is an autogenerated conversion function.
func Convert_v1_PodLogOptions_To_core_PodLogOptions(in *corev1.PodLogOptions, out *core.PodLogOptions, s conversion.Scope) error {
        return autoConvert_v1_PodLogOptions_To_core_PodLogOptions(in, out, s)
}

func autoConvert_core_PodLogOptions_To_v1_PodLogOptions(in *core.PodLogOptions, out *corev1.PodLogOptions, s conversion.Scope) error {
        out.Container = in.Container
        out.Follow = in.Follow
        out.Previous = in.Previous
        out.SinceSeconds = (*int64)(unsafe.Pointer(in.SinceSeconds))
        out.SinceTime = (*metav1.Time)(unsafe.Pointer(in.SinceTime))
        out.Timestamps = in.Timestamps
        out.TailLines = (*int64)(unsafe.Pointer(in.TailLines))
        out.LimitBytes = (*int64)(unsafe.Pointer(in.LimitBytes))
        out.InsecureSkipTLSVerifyBackend = in.InsecureSkipTLSVerifyBackend
        out.Stream = (*string)(unsafe.Pointer(in.Stream))
        return nil
}

// Convert_core_PodLogOptions_To_v1_PodLogOptions is an autogenerated conversion function.
func Convert_core_PodLogOptions_To_v1_PodLogOptions(in *core.PodLogOptions, out *corev1.PodLogOptions, s conversion.Scope) error {
        return autoConvert_core_PodLogOptions_To_v1_PodLogOptions(in, out, s)
}

func autoConvert_url_Values_To_v1_PodLogOptions(in *url.Values, out *corev1.PodLogOptions, s conversion.Scope) error {
        // WARNING: Field TypeMeta does not have json tag, skipping.

        if values, ok := map[string][]string(*in)["container"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_string(&values, &out.Container, s); err != nil {
                        return err
                }
        } else {
                out.Container = ""
        }
        if values, ok := map[string][]string(*in)["follow"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Follow, s); err != nil {
                        return err
                }
        } else {
                out.Follow = false
        }
        if values, ok := map[string][]string(*in)["previous"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Previous, s); err != nil {
                        return err
                }
        } else {
                out.Previous = false
        }
        if values, ok := map[string][]string(*in)["sinceSeconds"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_Pointer_int64(&values, &out.SinceSeconds, s); err != nil {
                        return err
                }
        } else {
                out.SinceSeconds = nil
        }
        if values, ok := map[string][]string(*in)["sinceTime"]; ok && len(values) > 0 {
                if err := metav1.Convert_Slice_string_To_Pointer_v1_Time(&values, &out.SinceTime, s); err != nil {
                        return err
                }
        } else {
                out.SinceTime = nil
        }
        if values, ok := map[string][]string(*in)["timestamps"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.Timestamps, s); err != nil {
                        return err
                }
        } else {
                out.Timestamps = false
        }
        if values, ok := map[string][]string(*in)["tailLines"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_Pointer_int64(&values, &out.TailLines, s); err != nil {
                        return err
                }
        } else {
                out.TailLines = nil
        }
        if values, ok := map[string][]string(*in)["limitBytes"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_Pointer_int64(&values, &out.LimitBytes, s); err != nil {
                        return err
                }
        } else {
                out.LimitBytes = nil
        }
        if values, ok := map[string][]string(*in)["insecureSkipTLSVerifyBackend"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_bool(&values, &out.InsecureSkipTLSVerifyBackend, s); err != nil {
                        return err
                }
        } else {
                out.InsecureSkipTLSVerifyBackend = false
        }
        if values, ok := map[string][]string(*in)["stream"]; ok && len(values) > 0 {
                if err := Convert_Slice_string_To_Pointer_string(&values, &out.Stream, s); err != nil {
                        return err
                }
        } else {
                out.Stream = nil
        }
        return nil
}

// Convert_url_Values_To_v1_PodLogOptions is an autogenerated conversion function.
func Convert_url_Values_To_v1_PodLogOptions(in *url.Values, out *corev1.PodLogOptions, s conversion.Scope) error {
        return autoConvert_url_Values_To_v1_PodLogOptions(in, out, s)
}

func autoConvert_v1_PodOS_To_core_PodOS(in *corev1.PodOS, out *core.PodOS, s conversion.Scope) error {
        out.Name = core.OSName(in.Name)
        return nil
}

// Convert_v1_PodOS_To_core_PodOS is an autogenerated conversion function.
func Convert_v1_PodOS_To_core_PodOS(in *corev1.PodOS, out *core.PodOS, s conversion.Scope) error {
        return autoConvert_v1_PodOS_To_core_PodOS(in, out, s)
}

func autoConvert_core_PodOS_To_v1_PodOS(in *core.PodOS, out *corev1.PodOS, s conversion.Scope) error {
        out.Name = corev1.OSName(in.Name)
        return nil
}

// Convert_core_PodOS_To_v1_PodOS is an autogenerated conversion function.
func Convert_core_PodOS_To_v1_PodOS(in *core.PodOS, out *corev1.PodOS, s conversion.Scope) error {
        return autoConvert_core_PodOS_To_v1_PodOS(in, out, s)
}

func autoConvert_v1_PodPortForwardOptions_To_core_PodPortForwardOptions(in *corev1.PodPortForwardOptions, out *core.PodPortForwardOptions, s conversion.Scope) error {
        out.Ports = *(*[]int32)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_v1_PodPortForwardOptions_To_core_PodPortForwardOptions is an autogenerated conversion function.
func Convert_v1_PodPortForwardOptions_To_core_PodPortForwardOptions(in *corev1.PodPortForwardOptions, out *core.PodPortForwardOptions, s conversion.Scope) error {
        return autoConvert_v1_PodPortForwardOptions_To_core_PodPortForwardOptions(in, out, s)
}

func autoConvert_core_PodPortForwardOptions_To_v1_PodPortForwardOptions(in *core.PodPortForwardOptions, out *corev1.PodPortForwardOptions, s conversion.Scope) error {
        out.Ports = *(*[]int32)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_core_PodPortForwardOptions_To_v1_PodPortForwardOptions is an autogenerated conversion function.
func Convert_core_PodPortForwardOptions_To_v1_PodPortForwardOptions(in *core.PodPortForwardOptions, out *corev1.PodPortForwardOptions, s conversion.Scope) error {
        return autoConvert_core_PodPortForwardOptions_To_v1_PodPortForwardOptions(in, out, s)
}

func autoConvert_url_Values_To_v1_PodPortForwardOptions(in *url.Values, out *corev1.PodPortForwardOptions, s conversion.Scope) error {
        // WARNING: Field TypeMeta does not have json tag, skipping.

        if values, ok := map[string][]string(*in)["ports"]; ok && len(values) > 0 {
                if err := metav1.Convert_Slice_string_To_Slice_int32(&values, &out.Ports, s); err != nil {
                        return err
                }
        } else {
                out.Ports = nil
        }
        return nil
}

// Convert_url_Values_To_v1_PodPortForwardOptions is an autogenerated conversion function.
func Convert_url_Values_To_v1_PodPortForwardOptions(in *url.Values, out *corev1.PodPortForwardOptions, s conversion.Scope) error {
        return autoConvert_url_Values_To_v1_PodPortForwardOptions(in, out, s)
}

func autoConvert_v1_PodProxyOptions_To_core_PodProxyOptions(in *corev1.PodProxyOptions, out *core.PodProxyOptions, s conversion.Scope) error {
        out.Path = in.Path
        return nil
}

// Convert_v1_PodProxyOptions_To_core_PodProxyOptions is an autogenerated conversion function.
func Convert_v1_PodProxyOptions_To_core_PodProxyOptions(in *corev1.PodProxyOptions, out *core.PodProxyOptions, s conversion.Scope) error {
        return autoConvert_v1_PodProxyOptions_To_core_PodProxyOptions(in, out, s)
}

func autoConvert_core_PodProxyOptions_To_v1_PodProxyOptions(in *core.PodProxyOptions, out *corev1.PodProxyOptions, s conversion.Scope) error {
        out.Path = in.Path
        return nil
}

// Convert_core_PodProxyOptions_To_v1_PodProxyOptions is an autogenerated conversion function.
func Convert_core_PodProxyOptions_To_v1_PodProxyOptions(in *core.PodProxyOptions, out *corev1.PodProxyOptions, s conversion.Scope) error {
        return autoConvert_core_PodProxyOptions_To_v1_PodProxyOptions(in, out, s)
}

func autoConvert_url_Values_To_v1_PodProxyOptions(in *url.Values, out *corev1.PodProxyOptions, s conversion.Scope) error {
        // WARNING: Field TypeMeta does not have json tag, skipping.

        if values, ok := map[string][]string(*in)["path"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_string(&values, &out.Path, s); err != nil {
                        return err
                }
        } else {
                out.Path = ""
        }
        return nil
}

// Convert_url_Values_To_v1_PodProxyOptions is an autogenerated conversion function.
func Convert_url_Values_To_v1_PodProxyOptions(in *url.Values, out *corev1.PodProxyOptions, s conversion.Scope) error {
        return autoConvert_url_Values_To_v1_PodProxyOptions(in, out, s)
}

func autoConvert_v1_PodReadinessGate_To_core_PodReadinessGate(in *corev1.PodReadinessGate, out *core.PodReadinessGate, s conversion.Scope) error {
        out.ConditionType = core.PodConditionType(in.ConditionType)
        return nil
}

// Convert_v1_PodReadinessGate_To_core_PodReadinessGate is an autogenerated conversion function.
func Convert_v1_PodReadinessGate_To_core_PodReadinessGate(in *corev1.PodReadinessGate, out *core.PodReadinessGate, s conversion.Scope) error {
        return autoConvert_v1_PodReadinessGate_To_core_PodReadinessGate(in, out, s)
}

func autoConvert_core_PodReadinessGate_To_v1_PodReadinessGate(in *core.PodReadinessGate, out *corev1.PodReadinessGate, s conversion.Scope) error {
        out.ConditionType = corev1.PodConditionType(in.ConditionType)
        return nil
}

// Convert_core_PodReadinessGate_To_v1_PodReadinessGate is an autogenerated conversion function.
func Convert_core_PodReadinessGate_To_v1_PodReadinessGate(in *core.PodReadinessGate, out *corev1.PodReadinessGate, s conversion.Scope) error {
        return autoConvert_core_PodReadinessGate_To_v1_PodReadinessGate(in, out, s)
}

func autoConvert_v1_PodResourceClaim_To_core_PodResourceClaim(in *corev1.PodResourceClaim, out *core.PodResourceClaim, s conversion.Scope) error {
        out.Name = in.Name
        out.ResourceClaimName = (*string)(unsafe.Pointer(in.ResourceClaimName))
        out.ResourceClaimTemplateName = (*string)(unsafe.Pointer(in.ResourceClaimTemplateName))
        return nil
}

// Convert_v1_PodResourceClaim_To_core_PodResourceClaim is an autogenerated conversion function.
func Convert_v1_PodResourceClaim_To_core_PodResourceClaim(in *corev1.PodResourceClaim, out *core.PodResourceClaim, s conversion.Scope) error {
        return autoConvert_v1_PodResourceClaim_To_core_PodResourceClaim(in, out, s)
}

func autoConvert_core_PodResourceClaim_To_v1_PodResourceClaim(in *core.PodResourceClaim, out *corev1.PodResourceClaim, s conversion.Scope) error {
        out.Name = in.Name
        out.ResourceClaimName = (*string)(unsafe.Pointer(in.ResourceClaimName))
        out.ResourceClaimTemplateName = (*string)(unsafe.Pointer(in.ResourceClaimTemplateName))
        return nil
}

// Convert_core_PodResourceClaim_To_v1_PodResourceClaim is an autogenerated conversion function.
func Convert_core_PodResourceClaim_To_v1_PodResourceClaim(in *core.PodResourceClaim, out *corev1.PodResourceClaim, s conversion.Scope) error {
        return autoConvert_core_PodResourceClaim_To_v1_PodResourceClaim(in, out, s)
}

func autoConvert_v1_PodResourceClaimStatus_To_core_PodResourceClaimStatus(in *corev1.PodResourceClaimStatus, out *core.PodResourceClaimStatus, s conversion.Scope) error {
        out.Name = in.Name
        out.ResourceClaimName = (*string)(unsafe.Pointer(in.ResourceClaimName))
        return nil
}

// Convert_v1_PodResourceClaimStatus_To_core_PodResourceClaimStatus is an autogenerated conversion function.
func Convert_v1_PodResourceClaimStatus_To_core_PodResourceClaimStatus(in *corev1.PodResourceClaimStatus, out *core.PodResourceClaimStatus, s conversion.Scope) error {
        return autoConvert_v1_PodResourceClaimStatus_To_core_PodResourceClaimStatus(in, out, s)
}

func autoConvert_core_PodResourceClaimStatus_To_v1_PodResourceClaimStatus(in *core.PodResourceClaimStatus, out *corev1.PodResourceClaimStatus, s conversion.Scope) error {
        out.Name = in.Name
        out.ResourceClaimName = (*string)(unsafe.Pointer(in.ResourceClaimName))
        return nil
}

// Convert_core_PodResourceClaimStatus_To_v1_PodResourceClaimStatus is an autogenerated conversion function.
func Convert_core_PodResourceClaimStatus_To_v1_PodResourceClaimStatus(in *core.PodResourceClaimStatus, out *corev1.PodResourceClaimStatus, s conversion.Scope) error {
        return autoConvert_core_PodResourceClaimStatus_To_v1_PodResourceClaimStatus(in, out, s)
}

func autoConvert_v1_PodSchedulingGate_To_core_PodSchedulingGate(in *corev1.PodSchedulingGate, out *core.PodSchedulingGate, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_v1_PodSchedulingGate_To_core_PodSchedulingGate is an autogenerated conversion function.
func Convert_v1_PodSchedulingGate_To_core_PodSchedulingGate(in *corev1.PodSchedulingGate, out *core.PodSchedulingGate, s conversion.Scope) error {
        return autoConvert_v1_PodSchedulingGate_To_core_PodSchedulingGate(in, out, s)
}

func autoConvert_core_PodSchedulingGate_To_v1_PodSchedulingGate(in *core.PodSchedulingGate, out *corev1.PodSchedulingGate, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_core_PodSchedulingGate_To_v1_PodSchedulingGate is an autogenerated conversion function.
func Convert_core_PodSchedulingGate_To_v1_PodSchedulingGate(in *core.PodSchedulingGate, out *corev1.PodSchedulingGate, s conversion.Scope) error {
        return autoConvert_core_PodSchedulingGate_To_v1_PodSchedulingGate(in, out, s)
}

func autoConvert_v1_PodSecurityContext_To_core_PodSecurityContext(in *corev1.PodSecurityContext, out *core.PodSecurityContext, s conversion.Scope) error {
        out.SELinuxOptions = (*core.SELinuxOptions)(unsafe.Pointer(in.SELinuxOptions))
        out.WindowsOptions = (*core.WindowsSecurityContextOptions)(unsafe.Pointer(in.WindowsOptions))
        out.RunAsUser = (*int64)(unsafe.Pointer(in.RunAsUser))
        out.RunAsGroup = (*int64)(unsafe.Pointer(in.RunAsGroup))
        out.RunAsNonRoot = (*bool)(unsafe.Pointer(in.RunAsNonRoot))
        out.SupplementalGroups = *(*[]int64)(unsafe.Pointer(&in.SupplementalGroups))
        out.SupplementalGroupsPolicy = (*core.SupplementalGroupsPolicy)(unsafe.Pointer(in.SupplementalGroupsPolicy))
        out.FSGroup = (*int64)(unsafe.Pointer(in.FSGroup))
        out.Sysctls = *(*[]core.Sysctl)(unsafe.Pointer(&in.Sysctls))
        out.FSGroupChangePolicy = (*core.PodFSGroupChangePolicy)(unsafe.Pointer(in.FSGroupChangePolicy))
        out.SeccompProfile = (*core.SeccompProfile)(unsafe.Pointer(in.SeccompProfile))
        out.AppArmorProfile = (*core.AppArmorProfile)(unsafe.Pointer(in.AppArmorProfile))
        out.SELinuxChangePolicy = (*core.PodSELinuxChangePolicy)(unsafe.Pointer(in.SELinuxChangePolicy))
        return nil
}

// Convert_v1_PodSecurityContext_To_core_PodSecurityContext is an autogenerated conversion function.
func Convert_v1_PodSecurityContext_To_core_PodSecurityContext(in *corev1.PodSecurityContext, out *core.PodSecurityContext, s conversion.Scope) error {
        return autoConvert_v1_PodSecurityContext_To_core_PodSecurityContext(in, out, s)
}

func autoConvert_core_PodSecurityContext_To_v1_PodSecurityContext(in *core.PodSecurityContext, out *corev1.PodSecurityContext, s conversion.Scope) error {
        // INFO: in.HostNetwork opted out of conversion generation
        // INFO: in.HostPID opted out of conversion generation
        // INFO: in.HostIPC opted out of conversion generation
        // INFO: in.ShareProcessNamespace opted out of conversion generation
        // INFO: in.HostUsers opted out of conversion generation
        out.SELinuxOptions = (*corev1.SELinuxOptions)(unsafe.Pointer(in.SELinuxOptions))
        out.WindowsOptions = (*corev1.WindowsSecurityContextOptions)(unsafe.Pointer(in.WindowsOptions))
        out.RunAsUser = (*int64)(unsafe.Pointer(in.RunAsUser))
        out.RunAsGroup = (*int64)(unsafe.Pointer(in.RunAsGroup))
        out.RunAsNonRoot = (*bool)(unsafe.Pointer(in.RunAsNonRoot))
        out.SupplementalGroups = *(*[]int64)(unsafe.Pointer(&in.SupplementalGroups))
        out.SupplementalGroupsPolicy = (*corev1.SupplementalGroupsPolicy)(unsafe.Pointer(in.SupplementalGroupsPolicy))
        out.FSGroup = (*int64)(unsafe.Pointer(in.FSGroup))
        out.FSGroupChangePolicy = (*corev1.PodFSGroupChangePolicy)(unsafe.Pointer(in.FSGroupChangePolicy))
        out.Sysctls = *(*[]corev1.Sysctl)(unsafe.Pointer(&in.Sysctls))
        out.SeccompProfile = (*corev1.SeccompProfile)(unsafe.Pointer(in.SeccompProfile))
        out.AppArmorProfile = (*corev1.AppArmorProfile)(unsafe.Pointer(in.AppArmorProfile))
        out.SELinuxChangePolicy = (*corev1.PodSELinuxChangePolicy)(unsafe.Pointer(in.SELinuxChangePolicy))
        return nil
}

// Convert_core_PodSecurityContext_To_v1_PodSecurityContext is an autogenerated conversion function.
func Convert_core_PodSecurityContext_To_v1_PodSecurityContext(in *core.PodSecurityContext, out *corev1.PodSecurityContext, s conversion.Scope) error {
        return autoConvert_core_PodSecurityContext_To_v1_PodSecurityContext(in, out, s)
}

func autoConvert_v1_PodSignature_To_core_PodSignature(in *corev1.PodSignature, out *core.PodSignature, s conversion.Scope) error {
        out.PodController = (*metav1.OwnerReference)(unsafe.Pointer(in.PodController))
        return nil
}

// Convert_v1_PodSignature_To_core_PodSignature is an autogenerated conversion function.
func Convert_v1_PodSignature_To_core_PodSignature(in *corev1.PodSignature, out *core.PodSignature, s conversion.Scope) error {
        return autoConvert_v1_PodSignature_To_core_PodSignature(in, out, s)
}

func autoConvert_core_PodSignature_To_v1_PodSignature(in *core.PodSignature, out *corev1.PodSignature, s conversion.Scope) error {
        out.PodController = (*metav1.OwnerReference)(unsafe.Pointer(in.PodController))
        return nil
}

// Convert_core_PodSignature_To_v1_PodSignature is an autogenerated conversion function.
func Convert_core_PodSignature_To_v1_PodSignature(in *core.PodSignature, out *corev1.PodSignature, s conversion.Scope) error {
        return autoConvert_core_PodSignature_To_v1_PodSignature(in, out, s)
}

func autoConvert_v1_PodSpec_To_core_PodSpec(in *corev1.PodSpec, out *core.PodSpec, s conversion.Scope) error {
        if in.Volumes != nil {
                in, out := &in.Volumes, &out.Volumes
                *out = make([]core.Volume, len(*in))
                for i := range *in {
                        if err := Convert_v1_Volume_To_core_Volume(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Volumes = nil
        }
        out.InitContainers = *(*[]core.Container)(unsafe.Pointer(&in.InitContainers))
        out.Containers = *(*[]core.Container)(unsafe.Pointer(&in.Containers))
        out.EphemeralContainers = *(*[]core.EphemeralContainer)(unsafe.Pointer(&in.EphemeralContainers))
        out.RestartPolicy = core.RestartPolicy(in.RestartPolicy)
        out.TerminationGracePeriodSeconds = (*int64)(unsafe.Pointer(in.TerminationGracePeriodSeconds))
        out.ActiveDeadlineSeconds = (*int64)(unsafe.Pointer(in.ActiveDeadlineSeconds))
        out.DNSPolicy = core.DNSPolicy(in.DNSPolicy)
        out.NodeSelector = *(*map[string]string)(unsafe.Pointer(&in.NodeSelector))
        out.ServiceAccountName = in.ServiceAccountName
        // INFO: in.DeprecatedServiceAccount opted out of conversion generation
        out.AutomountServiceAccountToken = (*bool)(unsafe.Pointer(in.AutomountServiceAccountToken))
        out.NodeName = in.NodeName
        // INFO: in.HostNetwork opted out of conversion generation
        // INFO: in.HostPID opted out of conversion generation
        // INFO: in.HostIPC opted out of conversion generation
        // INFO: in.ShareProcessNamespace opted out of conversion generation
        if in.SecurityContext != nil {
                in, out := &in.SecurityContext, &out.SecurityContext
                *out = new(core.PodSecurityContext)
                if err := Convert_v1_PodSecurityContext_To_core_PodSecurityContext(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.SecurityContext = nil
        }
        out.ImagePullSecrets = *(*[]core.LocalObjectReference)(unsafe.Pointer(&in.ImagePullSecrets))
        out.Hostname = in.Hostname
        out.Subdomain = in.Subdomain
        out.Affinity = (*core.Affinity)(unsafe.Pointer(in.Affinity))
        out.SchedulerName = in.SchedulerName
        out.Tolerations = *(*[]core.Toleration)(unsafe.Pointer(&in.Tolerations))
        out.HostAliases = *(*[]core.HostAlias)(unsafe.Pointer(&in.HostAliases))
        out.PriorityClassName = in.PriorityClassName
        out.Priority = (*int32)(unsafe.Pointer(in.Priority))
        out.DNSConfig = (*core.PodDNSConfig)(unsafe.Pointer(in.DNSConfig))
        out.ReadinessGates = *(*[]core.PodReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
        out.RuntimeClassName = (*string)(unsafe.Pointer(in.RuntimeClassName))
        out.EnableServiceLinks = (*bool)(unsafe.Pointer(in.EnableServiceLinks))
        out.PreemptionPolicy = (*core.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy))
        out.Overhead = *(*core.ResourceList)(unsafe.Pointer(&in.Overhead))
        out.TopologySpreadConstraints = *(*[]core.TopologySpreadConstraint)(unsafe.Pointer(&in.TopologySpreadConstraints))
        out.SetHostnameAsFQDN = (*bool)(unsafe.Pointer(in.SetHostnameAsFQDN))
        out.OS = (*core.PodOS)(unsafe.Pointer(in.OS))
        // INFO: in.HostUsers opted out of conversion generation
        out.SchedulingGates = *(*[]core.PodSchedulingGate)(unsafe.Pointer(&in.SchedulingGates))
        out.ResourceClaims = *(*[]core.PodResourceClaim)(unsafe.Pointer(&in.ResourceClaims))
        out.Resources = (*core.ResourceRequirements)(unsafe.Pointer(in.Resources))
        out.HostnameOverride = (*string)(unsafe.Pointer(in.HostnameOverride))
        return nil
}

func autoConvert_core_PodSpec_To_v1_PodSpec(in *core.PodSpec, out *corev1.PodSpec, s conversion.Scope) error {
        if in.Volumes != nil {
                in, out := &in.Volumes, &out.Volumes
                *out = make([]corev1.Volume, len(*in))
                for i := range *in {
                        if err := Convert_core_Volume_To_v1_Volume(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Volumes = nil
        }
        out.InitContainers = *(*[]corev1.Container)(unsafe.Pointer(&in.InitContainers))
        out.Containers = *(*[]corev1.Container)(unsafe.Pointer(&in.Containers))
        out.EphemeralContainers = *(*[]corev1.EphemeralContainer)(unsafe.Pointer(&in.EphemeralContainers))
        out.RestartPolicy = corev1.RestartPolicy(in.RestartPolicy)
        out.TerminationGracePeriodSeconds = (*int64)(unsafe.Pointer(in.TerminationGracePeriodSeconds))
        out.ActiveDeadlineSeconds = (*int64)(unsafe.Pointer(in.ActiveDeadlineSeconds))
        out.DNSPolicy = corev1.DNSPolicy(in.DNSPolicy)
        out.NodeSelector = *(*map[string]string)(unsafe.Pointer(&in.NodeSelector))
        out.ServiceAccountName = in.ServiceAccountName
        out.AutomountServiceAccountToken = (*bool)(unsafe.Pointer(in.AutomountServiceAccountToken))
        out.NodeName = in.NodeName
        if in.SecurityContext != nil {
                in, out := &in.SecurityContext, &out.SecurityContext
                *out = new(corev1.PodSecurityContext)
                if err := Convert_core_PodSecurityContext_To_v1_PodSecurityContext(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.SecurityContext = nil
        }
        out.ImagePullSecrets = *(*[]corev1.LocalObjectReference)(unsafe.Pointer(&in.ImagePullSecrets))
        out.Hostname = in.Hostname
        out.Subdomain = in.Subdomain
        out.SetHostnameAsFQDN = (*bool)(unsafe.Pointer(in.SetHostnameAsFQDN))
        out.Affinity = (*corev1.Affinity)(unsafe.Pointer(in.Affinity))
        out.SchedulerName = in.SchedulerName
        out.Tolerations = *(*[]corev1.Toleration)(unsafe.Pointer(&in.Tolerations))
        out.HostAliases = *(*[]corev1.HostAlias)(unsafe.Pointer(&in.HostAliases))
        out.PriorityClassName = in.PriorityClassName
        out.Priority = (*int32)(unsafe.Pointer(in.Priority))
        out.PreemptionPolicy = (*corev1.PreemptionPolicy)(unsafe.Pointer(in.PreemptionPolicy))
        out.DNSConfig = (*corev1.PodDNSConfig)(unsafe.Pointer(in.DNSConfig))
        out.ReadinessGates = *(*[]corev1.PodReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
        out.RuntimeClassName = (*string)(unsafe.Pointer(in.RuntimeClassName))
        out.Overhead = *(*corev1.ResourceList)(unsafe.Pointer(&in.Overhead))
        out.EnableServiceLinks = (*bool)(unsafe.Pointer(in.EnableServiceLinks))
        out.TopologySpreadConstraints = *(*[]corev1.TopologySpreadConstraint)(unsafe.Pointer(&in.TopologySpreadConstraints))
        out.OS = (*corev1.PodOS)(unsafe.Pointer(in.OS))
        out.SchedulingGates = *(*[]corev1.PodSchedulingGate)(unsafe.Pointer(&in.SchedulingGates))
        out.ResourceClaims = *(*[]corev1.PodResourceClaim)(unsafe.Pointer(&in.ResourceClaims))
        out.Resources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.Resources))
        out.HostnameOverride = (*string)(unsafe.Pointer(in.HostnameOverride))
        return nil
}

func autoConvert_v1_PodStatus_To_core_PodStatus(in *corev1.PodStatus, out *core.PodStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Phase = core.PodPhase(in.Phase)
        out.Conditions = *(*[]core.PodCondition)(unsafe.Pointer(&in.Conditions))
        out.Message = in.Message
        out.Reason = in.Reason
        out.NominatedNodeName = in.NominatedNodeName
        out.HostIP = in.HostIP
        out.HostIPs = *(*[]core.HostIP)(unsafe.Pointer(&in.HostIPs))
        // WARNING: in.PodIP requires manual conversion: does not exist in peer-type
        out.PodIPs = *(*[]core.PodIP)(unsafe.Pointer(&in.PodIPs))
        out.StartTime = (*metav1.Time)(unsafe.Pointer(in.StartTime))
        out.InitContainerStatuses = *(*[]core.ContainerStatus)(unsafe.Pointer(&in.InitContainerStatuses))
        out.ContainerStatuses = *(*[]core.ContainerStatus)(unsafe.Pointer(&in.ContainerStatuses))
        out.QOSClass = core.PodQOSClass(in.QOSClass)
        out.EphemeralContainerStatuses = *(*[]core.ContainerStatus)(unsafe.Pointer(&in.EphemeralContainerStatuses))
        out.Resize = core.PodResizeStatus(in.Resize)
        out.ResourceClaimStatuses = *(*[]core.PodResourceClaimStatus)(unsafe.Pointer(&in.ResourceClaimStatuses))
        out.ExtendedResourceClaimStatus = (*core.PodExtendedResourceClaimStatus)(unsafe.Pointer(in.ExtendedResourceClaimStatus))
        return nil
}

func autoConvert_core_PodStatus_To_v1_PodStatus(in *core.PodStatus, out *corev1.PodStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Phase = corev1.PodPhase(in.Phase)
        out.Conditions = *(*[]corev1.PodCondition)(unsafe.Pointer(&in.Conditions))
        out.Message = in.Message
        out.Reason = in.Reason
        out.NominatedNodeName = in.NominatedNodeName
        out.HostIP = in.HostIP
        out.HostIPs = *(*[]corev1.HostIP)(unsafe.Pointer(&in.HostIPs))
        out.PodIPs = *(*[]corev1.PodIP)(unsafe.Pointer(&in.PodIPs))
        out.StartTime = (*metav1.Time)(unsafe.Pointer(in.StartTime))
        out.QOSClass = corev1.PodQOSClass(in.QOSClass)
        out.InitContainerStatuses = *(*[]corev1.ContainerStatus)(unsafe.Pointer(&in.InitContainerStatuses))
        out.ContainerStatuses = *(*[]corev1.ContainerStatus)(unsafe.Pointer(&in.ContainerStatuses))
        out.EphemeralContainerStatuses = *(*[]corev1.ContainerStatus)(unsafe.Pointer(&in.EphemeralContainerStatuses))
        out.Resize = corev1.PodResizeStatus(in.Resize)
        out.ResourceClaimStatuses = *(*[]corev1.PodResourceClaimStatus)(unsafe.Pointer(&in.ResourceClaimStatuses))
        out.ExtendedResourceClaimStatus = (*corev1.PodExtendedResourceClaimStatus)(unsafe.Pointer(in.ExtendedResourceClaimStatus))
        return nil
}

func autoConvert_v1_PodStatusResult_To_core_PodStatusResult(in *corev1.PodStatusResult, out *core.PodStatusResult, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_PodStatus_To_core_PodStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_PodStatusResult_To_core_PodStatusResult is an autogenerated conversion function.
func Convert_v1_PodStatusResult_To_core_PodStatusResult(in *corev1.PodStatusResult, out *core.PodStatusResult, s conversion.Scope) error {
        return autoConvert_v1_PodStatusResult_To_core_PodStatusResult(in, out, s)
}

func autoConvert_core_PodStatusResult_To_v1_PodStatusResult(in *core.PodStatusResult, out *corev1.PodStatusResult, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_PodStatus_To_v1_PodStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_PodStatusResult_To_v1_PodStatusResult is an autogenerated conversion function.
func Convert_core_PodStatusResult_To_v1_PodStatusResult(in *core.PodStatusResult, out *corev1.PodStatusResult, s conversion.Scope) error {
        return autoConvert_core_PodStatusResult_To_v1_PodStatusResult(in, out, s)
}

func autoConvert_v1_PodTemplate_To_core_PodTemplate(in *corev1.PodTemplate, out *core.PodTemplate, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_PodTemplate_To_core_PodTemplate is an autogenerated conversion function.
func Convert_v1_PodTemplate_To_core_PodTemplate(in *corev1.PodTemplate, out *core.PodTemplate, s conversion.Scope) error {
        return autoConvert_v1_PodTemplate_To_core_PodTemplate(in, out, s)
}

func autoConvert_core_PodTemplate_To_v1_PodTemplate(in *core.PodTemplate, out *corev1.PodTemplate, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_PodTemplate_To_v1_PodTemplate is an autogenerated conversion function.
func Convert_core_PodTemplate_To_v1_PodTemplate(in *core.PodTemplate, out *corev1.PodTemplate, s conversion.Scope) error {
        return autoConvert_core_PodTemplate_To_v1_PodTemplate(in, out, s)
}

func autoConvert_v1_PodTemplateList_To_core_PodTemplateList(in *corev1.PodTemplateList, out *core.PodTemplateList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.PodTemplate, len(*in))
                for i := range *in {
                        if err := Convert_v1_PodTemplate_To_core_PodTemplate(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_PodTemplateList_To_core_PodTemplateList is an autogenerated conversion function.
func Convert_v1_PodTemplateList_To_core_PodTemplateList(in *corev1.PodTemplateList, out *core.PodTemplateList, s conversion.Scope) error {
        return autoConvert_v1_PodTemplateList_To_core_PodTemplateList(in, out, s)
}

func autoConvert_core_PodTemplateList_To_v1_PodTemplateList(in *core.PodTemplateList, out *corev1.PodTemplateList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]corev1.PodTemplate, len(*in))
                for i := range *in {
                        if err := Convert_core_PodTemplate_To_v1_PodTemplate(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_PodTemplateList_To_v1_PodTemplateList is an autogenerated conversion function.
func Convert_core_PodTemplateList_To_v1_PodTemplateList(in *core.PodTemplateList, out *corev1.PodTemplateList, s conversion.Scope) error {
        return autoConvert_core_PodTemplateList_To_v1_PodTemplateList(in, out, s)
}

func autoConvert_v1_PodTemplateSpec_To_core_PodTemplateSpec(in *corev1.PodTemplateSpec, out *core.PodTemplateSpec, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_PodSpec_To_core_PodSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_core_PodTemplateSpec_To_v1_PodTemplateSpec(in *core.PodTemplateSpec, out *corev1.PodTemplateSpec, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_PodSpec_To_v1_PodSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_PortStatus_To_core_PortStatus(in *corev1.PortStatus, out *core.PortStatus, s conversion.Scope) error {
        out.Port = in.Port
        out.Protocol = core.Protocol(in.Protocol)
        out.Error = (*string)(unsafe.Pointer(in.Error))
        return nil
}

// Convert_v1_PortStatus_To_core_PortStatus is an autogenerated conversion function.
func Convert_v1_PortStatus_To_core_PortStatus(in *corev1.PortStatus, out *core.PortStatus, s conversion.Scope) error {
        return autoConvert_v1_PortStatus_To_core_PortStatus(in, out, s)
}

func autoConvert_core_PortStatus_To_v1_PortStatus(in *core.PortStatus, out *corev1.PortStatus, s conversion.Scope) error {
        out.Port = in.Port
        out.Protocol = corev1.Protocol(in.Protocol)
        out.Error = (*string)(unsafe.Pointer(in.Error))
        return nil
}

// Convert_core_PortStatus_To_v1_PortStatus is an autogenerated conversion function.
func Convert_core_PortStatus_To_v1_PortStatus(in *core.PortStatus, out *corev1.PortStatus, s conversion.Scope) error {
        return autoConvert_core_PortStatus_To_v1_PortStatus(in, out, s)
}

func autoConvert_v1_PortworxVolumeSource_To_core_PortworxVolumeSource(in *corev1.PortworxVolumeSource, out *core.PortworxVolumeSource, s conversion.Scope) error {
        out.VolumeID = in.VolumeID
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_PortworxVolumeSource_To_core_PortworxVolumeSource is an autogenerated conversion function.
func Convert_v1_PortworxVolumeSource_To_core_PortworxVolumeSource(in *corev1.PortworxVolumeSource, out *core.PortworxVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_PortworxVolumeSource_To_core_PortworxVolumeSource(in, out, s)
}

func autoConvert_core_PortworxVolumeSource_To_v1_PortworxVolumeSource(in *core.PortworxVolumeSource, out *corev1.PortworxVolumeSource, s conversion.Scope) error {
        out.VolumeID = in.VolumeID
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_PortworxVolumeSource_To_v1_PortworxVolumeSource is an autogenerated conversion function.
func Convert_core_PortworxVolumeSource_To_v1_PortworxVolumeSource(in *core.PortworxVolumeSource, out *corev1.PortworxVolumeSource, s conversion.Scope) error {
        return autoConvert_core_PortworxVolumeSource_To_v1_PortworxVolumeSource(in, out, s)
}

func autoConvert_v1_Preconditions_To_core_Preconditions(in *corev1.Preconditions, out *core.Preconditions, s conversion.Scope) error {
        out.UID = (*types.UID)(unsafe.Pointer(in.UID))
        return nil
}

// Convert_v1_Preconditions_To_core_Preconditions is an autogenerated conversion function.
func Convert_v1_Preconditions_To_core_Preconditions(in *corev1.Preconditions, out *core.Preconditions, s conversion.Scope) error {
        return autoConvert_v1_Preconditions_To_core_Preconditions(in, out, s)
}

func autoConvert_core_Preconditions_To_v1_Preconditions(in *core.Preconditions, out *corev1.Preconditions, s conversion.Scope) error {
        out.UID = (*types.UID)(unsafe.Pointer(in.UID))
        return nil
}

// Convert_core_Preconditions_To_v1_Preconditions is an autogenerated conversion function.
func Convert_core_Preconditions_To_v1_Preconditions(in *core.Preconditions, out *corev1.Preconditions, s conversion.Scope) error {
        return autoConvert_core_Preconditions_To_v1_Preconditions(in, out, s)
}

func autoConvert_v1_PreferAvoidPodsEntry_To_core_PreferAvoidPodsEntry(in *corev1.PreferAvoidPodsEntry, out *core.PreferAvoidPodsEntry, s conversion.Scope) error {
        if err := Convert_v1_PodSignature_To_core_PodSignature(&in.PodSignature, &out.PodSignature, s); err != nil {
                return err
        }
        out.EvictionTime = in.EvictionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_PreferAvoidPodsEntry_To_core_PreferAvoidPodsEntry is an autogenerated conversion function.
func Convert_v1_PreferAvoidPodsEntry_To_core_PreferAvoidPodsEntry(in *corev1.PreferAvoidPodsEntry, out *core.PreferAvoidPodsEntry, s conversion.Scope) error {
        return autoConvert_v1_PreferAvoidPodsEntry_To_core_PreferAvoidPodsEntry(in, out, s)
}

func autoConvert_core_PreferAvoidPodsEntry_To_v1_PreferAvoidPodsEntry(in *core.PreferAvoidPodsEntry, out *corev1.PreferAvoidPodsEntry, s conversion.Scope) error {
        if err := Convert_core_PodSignature_To_v1_PodSignature(&in.PodSignature, &out.PodSignature, s); err != nil {
                return err
        }
        out.EvictionTime = in.EvictionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_core_PreferAvoidPodsEntry_To_v1_PreferAvoidPodsEntry is an autogenerated conversion function.
func Convert_core_PreferAvoidPodsEntry_To_v1_PreferAvoidPodsEntry(in *core.PreferAvoidPodsEntry, out *corev1.PreferAvoidPodsEntry, s conversion.Scope) error {
        return autoConvert_core_PreferAvoidPodsEntry_To_v1_PreferAvoidPodsEntry(in, out, s)
}

func autoConvert_v1_PreferredSchedulingTerm_To_core_PreferredSchedulingTerm(in *corev1.PreferredSchedulingTerm, out *core.PreferredSchedulingTerm, s conversion.Scope) error {
        out.Weight = in.Weight
        if err := Convert_v1_NodeSelectorTerm_To_core_NodeSelectorTerm(&in.Preference, &out.Preference, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_PreferredSchedulingTerm_To_core_PreferredSchedulingTerm is an autogenerated conversion function.
func Convert_v1_PreferredSchedulingTerm_To_core_PreferredSchedulingTerm(in *corev1.PreferredSchedulingTerm, out *core.PreferredSchedulingTerm, s conversion.Scope) error {
        return autoConvert_v1_PreferredSchedulingTerm_To_core_PreferredSchedulingTerm(in, out, s)
}

func autoConvert_core_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm(in *core.PreferredSchedulingTerm, out *corev1.PreferredSchedulingTerm, s conversion.Scope) error {
        out.Weight = in.Weight
        if err := Convert_core_NodeSelectorTerm_To_v1_NodeSelectorTerm(&in.Preference, &out.Preference, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm is an autogenerated conversion function.
func Convert_core_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm(in *core.PreferredSchedulingTerm, out *corev1.PreferredSchedulingTerm, s conversion.Scope) error {
        return autoConvert_core_PreferredSchedulingTerm_To_v1_PreferredSchedulingTerm(in, out, s)
}

func autoConvert_v1_Probe_To_core_Probe(in *corev1.Probe, out *core.Probe, s conversion.Scope) error {
        if err := Convert_v1_ProbeHandler_To_core_ProbeHandler(&in.ProbeHandler, &out.ProbeHandler, s); err != nil {
                return err
        }
        out.InitialDelaySeconds = in.InitialDelaySeconds
        out.TimeoutSeconds = in.TimeoutSeconds
        out.PeriodSeconds = in.PeriodSeconds
        out.SuccessThreshold = in.SuccessThreshold
        out.FailureThreshold = in.FailureThreshold
        out.TerminationGracePeriodSeconds = (*int64)(unsafe.Pointer(in.TerminationGracePeriodSeconds))
        return nil
}

// Convert_v1_Probe_To_core_Probe is an autogenerated conversion function.
func Convert_v1_Probe_To_core_Probe(in *corev1.Probe, out *core.Probe, s conversion.Scope) error {
        return autoConvert_v1_Probe_To_core_Probe(in, out, s)
}

func autoConvert_core_Probe_To_v1_Probe(in *core.Probe, out *corev1.Probe, s conversion.Scope) error {
        if err := Convert_core_ProbeHandler_To_v1_ProbeHandler(&in.ProbeHandler, &out.ProbeHandler, s); err != nil {
                return err
        }
        out.InitialDelaySeconds = in.InitialDelaySeconds
        out.TimeoutSeconds = in.TimeoutSeconds
        out.PeriodSeconds = in.PeriodSeconds
        out.SuccessThreshold = in.SuccessThreshold
        out.FailureThreshold = in.FailureThreshold
        out.TerminationGracePeriodSeconds = (*int64)(unsafe.Pointer(in.TerminationGracePeriodSeconds))
        return nil
}

// Convert_core_Probe_To_v1_Probe is an autogenerated conversion function.
func Convert_core_Probe_To_v1_Probe(in *core.Probe, out *corev1.Probe, s conversion.Scope) error {
        return autoConvert_core_Probe_To_v1_Probe(in, out, s)
}

func autoConvert_v1_ProbeHandler_To_core_ProbeHandler(in *corev1.ProbeHandler, out *core.ProbeHandler, s conversion.Scope) error {
        out.Exec = (*core.ExecAction)(unsafe.Pointer(in.Exec))
        out.HTTPGet = (*core.HTTPGetAction)(unsafe.Pointer(in.HTTPGet))
        out.TCPSocket = (*core.TCPSocketAction)(unsafe.Pointer(in.TCPSocket))
        out.GRPC = (*core.GRPCAction)(unsafe.Pointer(in.GRPC))
        return nil
}

// Convert_v1_ProbeHandler_To_core_ProbeHandler is an autogenerated conversion function.
func Convert_v1_ProbeHandler_To_core_ProbeHandler(in *corev1.ProbeHandler, out *core.ProbeHandler, s conversion.Scope) error {
        return autoConvert_v1_ProbeHandler_To_core_ProbeHandler(in, out, s)
}

func autoConvert_core_ProbeHandler_To_v1_ProbeHandler(in *core.ProbeHandler, out *corev1.ProbeHandler, s conversion.Scope) error {
        out.Exec = (*corev1.ExecAction)(unsafe.Pointer(in.Exec))
        out.HTTPGet = (*corev1.HTTPGetAction)(unsafe.Pointer(in.HTTPGet))
        out.TCPSocket = (*corev1.TCPSocketAction)(unsafe.Pointer(in.TCPSocket))
        out.GRPC = (*corev1.GRPCAction)(unsafe.Pointer(in.GRPC))
        return nil
}

// Convert_core_ProbeHandler_To_v1_ProbeHandler is an autogenerated conversion function.
func Convert_core_ProbeHandler_To_v1_ProbeHandler(in *core.ProbeHandler, out *corev1.ProbeHandler, s conversion.Scope) error {
        return autoConvert_core_ProbeHandler_To_v1_ProbeHandler(in, out, s)
}

func autoConvert_v1_ProjectedVolumeSource_To_core_ProjectedVolumeSource(in *corev1.ProjectedVolumeSource, out *core.ProjectedVolumeSource, s conversion.Scope) error {
        if in.Sources != nil {
                in, out := &in.Sources, &out.Sources
                *out = make([]core.VolumeProjection, len(*in))
                for i := range *in {
                        if err := Convert_v1_VolumeProjection_To_core_VolumeProjection(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Sources = nil
        }
        out.DefaultMode = (*int32)(unsafe.Pointer(in.DefaultMode))
        return nil
}

// Convert_v1_ProjectedVolumeSource_To_core_ProjectedVolumeSource is an autogenerated conversion function.
func Convert_v1_ProjectedVolumeSource_To_core_ProjectedVolumeSource(in *corev1.ProjectedVolumeSource, out *core.ProjectedVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_ProjectedVolumeSource_To_core_ProjectedVolumeSource(in, out, s)
}

func autoConvert_core_ProjectedVolumeSource_To_v1_ProjectedVolumeSource(in *core.ProjectedVolumeSource, out *corev1.ProjectedVolumeSource, s conversion.Scope) error {
        if in.Sources != nil {
                in, out := &in.Sources, &out.Sources
                *out = make([]corev1.VolumeProjection, len(*in))
                for i := range *in {
                        if err := Convert_core_VolumeProjection_To_v1_VolumeProjection(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Sources = nil
        }
        out.DefaultMode = (*int32)(unsafe.Pointer(in.DefaultMode))
        return nil
}

// Convert_core_ProjectedVolumeSource_To_v1_ProjectedVolumeSource is an autogenerated conversion function.
func Convert_core_ProjectedVolumeSource_To_v1_ProjectedVolumeSource(in *core.ProjectedVolumeSource, out *corev1.ProjectedVolumeSource, s conversion.Scope) error {
        return autoConvert_core_ProjectedVolumeSource_To_v1_ProjectedVolumeSource(in, out, s)
}

func autoConvert_v1_QuobyteVolumeSource_To_core_QuobyteVolumeSource(in *corev1.QuobyteVolumeSource, out *core.QuobyteVolumeSource, s conversion.Scope) error {
        out.Registry = in.Registry
        out.Volume = in.Volume
        out.ReadOnly = in.ReadOnly
        out.User = in.User
        out.Group = in.Group
        out.Tenant = in.Tenant
        return nil
}

// Convert_v1_QuobyteVolumeSource_To_core_QuobyteVolumeSource is an autogenerated conversion function.
func Convert_v1_QuobyteVolumeSource_To_core_QuobyteVolumeSource(in *corev1.QuobyteVolumeSource, out *core.QuobyteVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_QuobyteVolumeSource_To_core_QuobyteVolumeSource(in, out, s)
}

func autoConvert_core_QuobyteVolumeSource_To_v1_QuobyteVolumeSource(in *core.QuobyteVolumeSource, out *corev1.QuobyteVolumeSource, s conversion.Scope) error {
        out.Registry = in.Registry
        out.Volume = in.Volume
        out.ReadOnly = in.ReadOnly
        out.User = in.User
        out.Group = in.Group
        out.Tenant = in.Tenant
        return nil
}

// Convert_core_QuobyteVolumeSource_To_v1_QuobyteVolumeSource is an autogenerated conversion function.
func Convert_core_QuobyteVolumeSource_To_v1_QuobyteVolumeSource(in *core.QuobyteVolumeSource, out *corev1.QuobyteVolumeSource, s conversion.Scope) error {
        return autoConvert_core_QuobyteVolumeSource_To_v1_QuobyteVolumeSource(in, out, s)
}

func autoConvert_v1_RBDPersistentVolumeSource_To_core_RBDPersistentVolumeSource(in *corev1.RBDPersistentVolumeSource, out *core.RBDPersistentVolumeSource, s conversion.Scope) error {
        out.CephMonitors = *(*[]string)(unsafe.Pointer(&in.CephMonitors))
        out.RBDImage = in.RBDImage
        out.FSType = in.FSType
        out.RBDPool = in.RBDPool
        out.RadosUser = in.RadosUser
        out.Keyring = in.Keyring
        out.SecretRef = (*core.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_RBDPersistentVolumeSource_To_core_RBDPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_RBDPersistentVolumeSource_To_core_RBDPersistentVolumeSource(in *corev1.RBDPersistentVolumeSource, out *core.RBDPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_RBDPersistentVolumeSource_To_core_RBDPersistentVolumeSource(in, out, s)
}

func autoConvert_core_RBDPersistentVolumeSource_To_v1_RBDPersistentVolumeSource(in *core.RBDPersistentVolumeSource, out *corev1.RBDPersistentVolumeSource, s conversion.Scope) error {
        out.CephMonitors = *(*[]string)(unsafe.Pointer(&in.CephMonitors))
        out.RBDImage = in.RBDImage
        out.FSType = in.FSType
        out.RBDPool = in.RBDPool
        out.RadosUser = in.RadosUser
        out.Keyring = in.Keyring
        out.SecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_RBDPersistentVolumeSource_To_v1_RBDPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_RBDPersistentVolumeSource_To_v1_RBDPersistentVolumeSource(in *core.RBDPersistentVolumeSource, out *corev1.RBDPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_RBDPersistentVolumeSource_To_v1_RBDPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_RBDVolumeSource_To_core_RBDVolumeSource(in *corev1.RBDVolumeSource, out *core.RBDVolumeSource, s conversion.Scope) error {
        out.CephMonitors = *(*[]string)(unsafe.Pointer(&in.CephMonitors))
        out.RBDImage = in.RBDImage
        out.FSType = in.FSType
        out.RBDPool = in.RBDPool
        out.RadosUser = in.RadosUser
        out.Keyring = in.Keyring
        out.SecretRef = (*core.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_RBDVolumeSource_To_core_RBDVolumeSource is an autogenerated conversion function.
func Convert_v1_RBDVolumeSource_To_core_RBDVolumeSource(in *corev1.RBDVolumeSource, out *core.RBDVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_RBDVolumeSource_To_core_RBDVolumeSource(in, out, s)
}

func autoConvert_core_RBDVolumeSource_To_v1_RBDVolumeSource(in *core.RBDVolumeSource, out *corev1.RBDVolumeSource, s conversion.Scope) error {
        out.CephMonitors = *(*[]string)(unsafe.Pointer(&in.CephMonitors))
        out.RBDImage = in.RBDImage
        out.FSType = in.FSType
        out.RBDPool = in.RBDPool
        out.RadosUser = in.RadosUser
        out.Keyring = in.Keyring
        out.SecretRef = (*corev1.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_RBDVolumeSource_To_v1_RBDVolumeSource is an autogenerated conversion function.
func Convert_core_RBDVolumeSource_To_v1_RBDVolumeSource(in *core.RBDVolumeSource, out *corev1.RBDVolumeSource, s conversion.Scope) error {
        return autoConvert_core_RBDVolumeSource_To_v1_RBDVolumeSource(in, out, s)
}

func autoConvert_v1_RangeAllocation_To_core_RangeAllocation(in *corev1.RangeAllocation, out *core.RangeAllocation, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Range = in.Range
        out.Data = *(*[]byte)(unsafe.Pointer(&in.Data))
        return nil
}

// Convert_v1_RangeAllocation_To_core_RangeAllocation is an autogenerated conversion function.
func Convert_v1_RangeAllocation_To_core_RangeAllocation(in *corev1.RangeAllocation, out *core.RangeAllocation, s conversion.Scope) error {
        return autoConvert_v1_RangeAllocation_To_core_RangeAllocation(in, out, s)
}

func autoConvert_core_RangeAllocation_To_v1_RangeAllocation(in *core.RangeAllocation, out *corev1.RangeAllocation, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Range = in.Range
        out.Data = *(*[]byte)(unsafe.Pointer(&in.Data))
        return nil
}

// Convert_core_RangeAllocation_To_v1_RangeAllocation is an autogenerated conversion function.
func Convert_core_RangeAllocation_To_v1_RangeAllocation(in *core.RangeAllocation, out *corev1.RangeAllocation, s conversion.Scope) error {
        return autoConvert_core_RangeAllocation_To_v1_RangeAllocation(in, out, s)
}

func autoConvert_v1_ReplicationController_To_core_ReplicationController(in *corev1.ReplicationController, out *core.ReplicationController, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ReplicationControllerSpec_To_core_ReplicationControllerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_ReplicationControllerStatus_To_core_ReplicationControllerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_ReplicationController_To_core_ReplicationController is an autogenerated conversion function.
func Convert_v1_ReplicationController_To_core_ReplicationController(in *corev1.ReplicationController, out *core.ReplicationController, s conversion.Scope) error {
        return autoConvert_v1_ReplicationController_To_core_ReplicationController(in, out, s)
}

func autoConvert_core_ReplicationController_To_v1_ReplicationController(in *core.ReplicationController, out *corev1.ReplicationController, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_core_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_ReplicationController_To_v1_ReplicationController is an autogenerated conversion function.
func Convert_core_ReplicationController_To_v1_ReplicationController(in *core.ReplicationController, out *corev1.ReplicationController, s conversion.Scope) error {
        return autoConvert_core_ReplicationController_To_v1_ReplicationController(in, out, s)
}

func autoConvert_v1_ReplicationControllerCondition_To_core_ReplicationControllerCondition(in *corev1.ReplicationControllerCondition, out *core.ReplicationControllerCondition, s conversion.Scope) error {
        out.Type = core.ReplicationControllerConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_ReplicationControllerCondition_To_core_ReplicationControllerCondition is an autogenerated conversion function.
func Convert_v1_ReplicationControllerCondition_To_core_ReplicationControllerCondition(in *corev1.ReplicationControllerCondition, out *core.ReplicationControllerCondition, s conversion.Scope) error {
        return autoConvert_v1_ReplicationControllerCondition_To_core_ReplicationControllerCondition(in, out, s)
}

func autoConvert_core_ReplicationControllerCondition_To_v1_ReplicationControllerCondition(in *core.ReplicationControllerCondition, out *corev1.ReplicationControllerCondition, s conversion.Scope) error {
        out.Type = corev1.ReplicationControllerConditionType(in.Type)
        out.Status = corev1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_core_ReplicationControllerCondition_To_v1_ReplicationControllerCondition is an autogenerated conversion function.
func Convert_core_ReplicationControllerCondition_To_v1_ReplicationControllerCondition(in *core.ReplicationControllerCondition, out *corev1.ReplicationControllerCondition, s conversion.Scope) error {
        return autoConvert_core_ReplicationControllerCondition_To_v1_ReplicationControllerCondition(in, out, s)
}

func autoConvert_v1_ReplicationControllerList_To_core_ReplicationControllerList(in *corev1.ReplicationControllerList, out *core.ReplicationControllerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.ReplicationController, len(*in))
                for i := range *in {
                        if err := Convert_v1_ReplicationController_To_core_ReplicationController(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_ReplicationControllerList_To_core_ReplicationControllerList is an autogenerated conversion function.
func Convert_v1_ReplicationControllerList_To_core_ReplicationControllerList(in *corev1.ReplicationControllerList, out *core.ReplicationControllerList, s conversion.Scope) error {
        return autoConvert_v1_ReplicationControllerList_To_core_ReplicationControllerList(in, out, s)
}

func autoConvert_core_ReplicationControllerList_To_v1_ReplicationControllerList(in *core.ReplicationControllerList, out *corev1.ReplicationControllerList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]corev1.ReplicationController, len(*in))
                for i := range *in {
                        if err := Convert_core_ReplicationController_To_v1_ReplicationController(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_ReplicationControllerList_To_v1_ReplicationControllerList is an autogenerated conversion function.
func Convert_core_ReplicationControllerList_To_v1_ReplicationControllerList(in *core.ReplicationControllerList, out *corev1.ReplicationControllerList, s conversion.Scope) error {
        return autoConvert_core_ReplicationControllerList_To_v1_ReplicationControllerList(in, out, s)
}

func autoConvert_v1_ReplicationControllerSpec_To_core_ReplicationControllerSpec(in *corev1.ReplicationControllerSpec, out *core.ReplicationControllerSpec, s conversion.Scope) error {
        out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = *(*map[string]string)(unsafe.Pointer(&in.Selector))
        if in.Template != nil {
                in, out := &in.Template, &out.Template
                *out = new(core.PodTemplateSpec)
                if err := Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Template = nil
        }
        return nil
}

func autoConvert_core_ReplicationControllerSpec_To_v1_ReplicationControllerSpec(in *core.ReplicationControllerSpec, out *corev1.ReplicationControllerSpec, s conversion.Scope) error {
        out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = *(*map[string]string)(unsafe.Pointer(&in.Selector))
        if in.Template != nil {
                in, out := &in.Template, &out.Template
                *out = new(corev1.PodTemplateSpec)
                if err := Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Template = nil
        }
        return nil
}

func autoConvert_v1_ReplicationControllerStatus_To_core_ReplicationControllerStatus(in *corev1.ReplicationControllerStatus, out *core.ReplicationControllerStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.ObservedGeneration = in.ObservedGeneration
        out.Conditions = *(*[]core.ReplicationControllerCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1_ReplicationControllerStatus_To_core_ReplicationControllerStatus is an autogenerated conversion function.
func Convert_v1_ReplicationControllerStatus_To_core_ReplicationControllerStatus(in *corev1.ReplicationControllerStatus, out *core.ReplicationControllerStatus, s conversion.Scope) error {
        return autoConvert_v1_ReplicationControllerStatus_To_core_ReplicationControllerStatus(in, out, s)
}

func autoConvert_core_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in *core.ReplicationControllerStatus, out *corev1.ReplicationControllerStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.ObservedGeneration = in.ObservedGeneration
        out.Conditions = *(*[]corev1.ReplicationControllerCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_core_ReplicationControllerStatus_To_v1_ReplicationControllerStatus is an autogenerated conversion function.
func Convert_core_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in *core.ReplicationControllerStatus, out *corev1.ReplicationControllerStatus, s conversion.Scope) error {
        return autoConvert_core_ReplicationControllerStatus_To_v1_ReplicationControllerStatus(in, out, s)
}

func autoConvert_v1_ResourceClaim_To_core_ResourceClaim(in *corev1.ResourceClaim, out *core.ResourceClaim, s conversion.Scope) error {
        out.Name = in.Name
        out.Request = in.Request
        return nil
}

// Convert_v1_ResourceClaim_To_core_ResourceClaim is an autogenerated conversion function.
func Convert_v1_ResourceClaim_To_core_ResourceClaim(in *corev1.ResourceClaim, out *core.ResourceClaim, s conversion.Scope) error {
        return autoConvert_v1_ResourceClaim_To_core_ResourceClaim(in, out, s)
}

func autoConvert_core_ResourceClaim_To_v1_ResourceClaim(in *core.ResourceClaim, out *corev1.ResourceClaim, s conversion.Scope) error {
        out.Name = in.Name
        out.Request = in.Request
        return nil
}

// Convert_core_ResourceClaim_To_v1_ResourceClaim is an autogenerated conversion function.
func Convert_core_ResourceClaim_To_v1_ResourceClaim(in *core.ResourceClaim, out *corev1.ResourceClaim, s conversion.Scope) error {
        return autoConvert_core_ResourceClaim_To_v1_ResourceClaim(in, out, s)
}

func autoConvert_v1_ResourceFieldSelector_To_core_ResourceFieldSelector(in *corev1.ResourceFieldSelector, out *core.ResourceFieldSelector, s conversion.Scope) error {
        out.ContainerName = in.ContainerName
        out.Resource = in.Resource
        out.Divisor = in.Divisor
        return nil
}

// Convert_v1_ResourceFieldSelector_To_core_ResourceFieldSelector is an autogenerated conversion function.
func Convert_v1_ResourceFieldSelector_To_core_ResourceFieldSelector(in *corev1.ResourceFieldSelector, out *core.ResourceFieldSelector, s conversion.Scope) error {
        return autoConvert_v1_ResourceFieldSelector_To_core_ResourceFieldSelector(in, out, s)
}

func autoConvert_core_ResourceFieldSelector_To_v1_ResourceFieldSelector(in *core.ResourceFieldSelector, out *corev1.ResourceFieldSelector, s conversion.Scope) error {
        out.ContainerName = in.ContainerName
        out.Resource = in.Resource
        out.Divisor = in.Divisor
        return nil
}

// Convert_core_ResourceFieldSelector_To_v1_ResourceFieldSelector is an autogenerated conversion function.
func Convert_core_ResourceFieldSelector_To_v1_ResourceFieldSelector(in *core.ResourceFieldSelector, out *corev1.ResourceFieldSelector, s conversion.Scope) error {
        return autoConvert_core_ResourceFieldSelector_To_v1_ResourceFieldSelector(in, out, s)
}

func autoConvert_v1_ResourceHealth_To_core_ResourceHealth(in *corev1.ResourceHealth, out *core.ResourceHealth, s conversion.Scope) error {
        out.ResourceID = core.ResourceID(in.ResourceID)
        out.Health = core.ResourceHealthStatus(in.Health)
        return nil
}

// Convert_v1_ResourceHealth_To_core_ResourceHealth is an autogenerated conversion function.
func Convert_v1_ResourceHealth_To_core_ResourceHealth(in *corev1.ResourceHealth, out *core.ResourceHealth, s conversion.Scope) error {
        return autoConvert_v1_ResourceHealth_To_core_ResourceHealth(in, out, s)
}

func autoConvert_core_ResourceHealth_To_v1_ResourceHealth(in *core.ResourceHealth, out *corev1.ResourceHealth, s conversion.Scope) error {
        out.ResourceID = corev1.ResourceID(in.ResourceID)
        out.Health = corev1.ResourceHealthStatus(in.Health)
        return nil
}

// Convert_core_ResourceHealth_To_v1_ResourceHealth is an autogenerated conversion function.
func Convert_core_ResourceHealth_To_v1_ResourceHealth(in *core.ResourceHealth, out *corev1.ResourceHealth, s conversion.Scope) error {
        return autoConvert_core_ResourceHealth_To_v1_ResourceHealth(in, out, s)
}

func autoConvert_v1_ResourceQuota_To_core_ResourceQuota(in *corev1.ResourceQuota, out *core.ResourceQuota, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ResourceQuotaSpec_To_core_ResourceQuotaSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_ResourceQuotaStatus_To_core_ResourceQuotaStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_ResourceQuota_To_core_ResourceQuota is an autogenerated conversion function.
func Convert_v1_ResourceQuota_To_core_ResourceQuota(in *corev1.ResourceQuota, out *core.ResourceQuota, s conversion.Scope) error {
        return autoConvert_v1_ResourceQuota_To_core_ResourceQuota(in, out, s)
}

func autoConvert_core_ResourceQuota_To_v1_ResourceQuota(in *core.ResourceQuota, out *corev1.ResourceQuota, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_core_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_ResourceQuota_To_v1_ResourceQuota is an autogenerated conversion function.
func Convert_core_ResourceQuota_To_v1_ResourceQuota(in *core.ResourceQuota, out *corev1.ResourceQuota, s conversion.Scope) error {
        return autoConvert_core_ResourceQuota_To_v1_ResourceQuota(in, out, s)
}

func autoConvert_v1_ResourceQuotaList_To_core_ResourceQuotaList(in *corev1.ResourceQuotaList, out *core.ResourceQuotaList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.ResourceQuota)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_ResourceQuotaList_To_core_ResourceQuotaList is an autogenerated conversion function.
func Convert_v1_ResourceQuotaList_To_core_ResourceQuotaList(in *corev1.ResourceQuotaList, out *core.ResourceQuotaList, s conversion.Scope) error {
        return autoConvert_v1_ResourceQuotaList_To_core_ResourceQuotaList(in, out, s)
}

func autoConvert_core_ResourceQuotaList_To_v1_ResourceQuotaList(in *core.ResourceQuotaList, out *corev1.ResourceQuotaList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.ResourceQuota)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_ResourceQuotaList_To_v1_ResourceQuotaList is an autogenerated conversion function.
func Convert_core_ResourceQuotaList_To_v1_ResourceQuotaList(in *core.ResourceQuotaList, out *corev1.ResourceQuotaList, s conversion.Scope) error {
        return autoConvert_core_ResourceQuotaList_To_v1_ResourceQuotaList(in, out, s)
}

func autoConvert_v1_ResourceQuotaSpec_To_core_ResourceQuotaSpec(in *corev1.ResourceQuotaSpec, out *core.ResourceQuotaSpec, s conversion.Scope) error {
        out.Hard = *(*core.ResourceList)(unsafe.Pointer(&in.Hard))
        out.Scopes = *(*[]core.ResourceQuotaScope)(unsafe.Pointer(&in.Scopes))
        out.ScopeSelector = (*core.ScopeSelector)(unsafe.Pointer(in.ScopeSelector))
        return nil
}

// Convert_v1_ResourceQuotaSpec_To_core_ResourceQuotaSpec is an autogenerated conversion function.
func Convert_v1_ResourceQuotaSpec_To_core_ResourceQuotaSpec(in *corev1.ResourceQuotaSpec, out *core.ResourceQuotaSpec, s conversion.Scope) error {
        return autoConvert_v1_ResourceQuotaSpec_To_core_ResourceQuotaSpec(in, out, s)
}

func autoConvert_core_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in *core.ResourceQuotaSpec, out *corev1.ResourceQuotaSpec, s conversion.Scope) error {
        out.Hard = *(*corev1.ResourceList)(unsafe.Pointer(&in.Hard))
        out.Scopes = *(*[]corev1.ResourceQuotaScope)(unsafe.Pointer(&in.Scopes))
        out.ScopeSelector = (*corev1.ScopeSelector)(unsafe.Pointer(in.ScopeSelector))
        return nil
}

// Convert_core_ResourceQuotaSpec_To_v1_ResourceQuotaSpec is an autogenerated conversion function.
func Convert_core_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in *core.ResourceQuotaSpec, out *corev1.ResourceQuotaSpec, s conversion.Scope) error {
        return autoConvert_core_ResourceQuotaSpec_To_v1_ResourceQuotaSpec(in, out, s)
}

func autoConvert_v1_ResourceQuotaStatus_To_core_ResourceQuotaStatus(in *corev1.ResourceQuotaStatus, out *core.ResourceQuotaStatus, s conversion.Scope) error {
        out.Hard = *(*core.ResourceList)(unsafe.Pointer(&in.Hard))
        out.Used = *(*core.ResourceList)(unsafe.Pointer(&in.Used))
        return nil
}

// Convert_v1_ResourceQuotaStatus_To_core_ResourceQuotaStatus is an autogenerated conversion function.
func Convert_v1_ResourceQuotaStatus_To_core_ResourceQuotaStatus(in *corev1.ResourceQuotaStatus, out *core.ResourceQuotaStatus, s conversion.Scope) error {
        return autoConvert_v1_ResourceQuotaStatus_To_core_ResourceQuotaStatus(in, out, s)
}

func autoConvert_core_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in *core.ResourceQuotaStatus, out *corev1.ResourceQuotaStatus, s conversion.Scope) error {
        out.Hard = *(*corev1.ResourceList)(unsafe.Pointer(&in.Hard))
        out.Used = *(*corev1.ResourceList)(unsafe.Pointer(&in.Used))
        return nil
}

// Convert_core_ResourceQuotaStatus_To_v1_ResourceQuotaStatus is an autogenerated conversion function.
func Convert_core_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in *core.ResourceQuotaStatus, out *corev1.ResourceQuotaStatus, s conversion.Scope) error {
        return autoConvert_core_ResourceQuotaStatus_To_v1_ResourceQuotaStatus(in, out, s)
}

func autoConvert_v1_ResourceRequirements_To_core_ResourceRequirements(in *corev1.ResourceRequirements, out *core.ResourceRequirements, s conversion.Scope) error {
        out.Limits = *(*core.ResourceList)(unsafe.Pointer(&in.Limits))
        out.Requests = *(*core.ResourceList)(unsafe.Pointer(&in.Requests))
        out.Claims = *(*[]core.ResourceClaim)(unsafe.Pointer(&in.Claims))
        return nil
}

// Convert_v1_ResourceRequirements_To_core_ResourceRequirements is an autogenerated conversion function.
func Convert_v1_ResourceRequirements_To_core_ResourceRequirements(in *corev1.ResourceRequirements, out *core.ResourceRequirements, s conversion.Scope) error {
        return autoConvert_v1_ResourceRequirements_To_core_ResourceRequirements(in, out, s)
}

func autoConvert_core_ResourceRequirements_To_v1_ResourceRequirements(in *core.ResourceRequirements, out *corev1.ResourceRequirements, s conversion.Scope) error {
        out.Limits = *(*corev1.ResourceList)(unsafe.Pointer(&in.Limits))
        out.Requests = *(*corev1.ResourceList)(unsafe.Pointer(&in.Requests))
        out.Claims = *(*[]corev1.ResourceClaim)(unsafe.Pointer(&in.Claims))
        return nil
}

// Convert_core_ResourceRequirements_To_v1_ResourceRequirements is an autogenerated conversion function.
func Convert_core_ResourceRequirements_To_v1_ResourceRequirements(in *core.ResourceRequirements, out *corev1.ResourceRequirements, s conversion.Scope) error {
        return autoConvert_core_ResourceRequirements_To_v1_ResourceRequirements(in, out, s)
}

func autoConvert_v1_ResourceStatus_To_core_ResourceStatus(in *corev1.ResourceStatus, out *core.ResourceStatus, s conversion.Scope) error {
        out.Name = core.ResourceName(in.Name)
        out.Resources = *(*[]core.ResourceHealth)(unsafe.Pointer(&in.Resources))
        return nil
}

// Convert_v1_ResourceStatus_To_core_ResourceStatus is an autogenerated conversion function.
func Convert_v1_ResourceStatus_To_core_ResourceStatus(in *corev1.ResourceStatus, out *core.ResourceStatus, s conversion.Scope) error {
        return autoConvert_v1_ResourceStatus_To_core_ResourceStatus(in, out, s)
}

func autoConvert_core_ResourceStatus_To_v1_ResourceStatus(in *core.ResourceStatus, out *corev1.ResourceStatus, s conversion.Scope) error {
        out.Name = corev1.ResourceName(in.Name)
        out.Resources = *(*[]corev1.ResourceHealth)(unsafe.Pointer(&in.Resources))
        return nil
}

// Convert_core_ResourceStatus_To_v1_ResourceStatus is an autogenerated conversion function.
func Convert_core_ResourceStatus_To_v1_ResourceStatus(in *core.ResourceStatus, out *corev1.ResourceStatus, s conversion.Scope) error {
        return autoConvert_core_ResourceStatus_To_v1_ResourceStatus(in, out, s)
}

func autoConvert_v1_SELinuxOptions_To_core_SELinuxOptions(in *corev1.SELinuxOptions, out *core.SELinuxOptions, s conversion.Scope) error {
        out.User = in.User
        out.Role = in.Role
        out.Type = in.Type
        out.Level = in.Level
        return nil
}

// Convert_v1_SELinuxOptions_To_core_SELinuxOptions is an autogenerated conversion function.
func Convert_v1_SELinuxOptions_To_core_SELinuxOptions(in *corev1.SELinuxOptions, out *core.SELinuxOptions, s conversion.Scope) error {
        return autoConvert_v1_SELinuxOptions_To_core_SELinuxOptions(in, out, s)
}

func autoConvert_core_SELinuxOptions_To_v1_SELinuxOptions(in *core.SELinuxOptions, out *corev1.SELinuxOptions, s conversion.Scope) error {
        out.User = in.User
        out.Role = in.Role
        out.Type = in.Type
        out.Level = in.Level
        return nil
}

// Convert_core_SELinuxOptions_To_v1_SELinuxOptions is an autogenerated conversion function.
func Convert_core_SELinuxOptions_To_v1_SELinuxOptions(in *core.SELinuxOptions, out *corev1.SELinuxOptions, s conversion.Scope) error {
        return autoConvert_core_SELinuxOptions_To_v1_SELinuxOptions(in, out, s)
}

func autoConvert_v1_ScaleIOPersistentVolumeSource_To_core_ScaleIOPersistentVolumeSource(in *corev1.ScaleIOPersistentVolumeSource, out *core.ScaleIOPersistentVolumeSource, s conversion.Scope) error {
        out.Gateway = in.Gateway
        out.System = in.System
        out.SecretRef = (*core.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.SSLEnabled = in.SSLEnabled
        out.ProtectionDomain = in.ProtectionDomain
        out.StoragePool = in.StoragePool
        out.StorageMode = in.StorageMode
        out.VolumeName = in.VolumeName
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_ScaleIOPersistentVolumeSource_To_core_ScaleIOPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_ScaleIOPersistentVolumeSource_To_core_ScaleIOPersistentVolumeSource(in *corev1.ScaleIOPersistentVolumeSource, out *core.ScaleIOPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_ScaleIOPersistentVolumeSource_To_core_ScaleIOPersistentVolumeSource(in, out, s)
}

func autoConvert_core_ScaleIOPersistentVolumeSource_To_v1_ScaleIOPersistentVolumeSource(in *core.ScaleIOPersistentVolumeSource, out *corev1.ScaleIOPersistentVolumeSource, s conversion.Scope) error {
        out.Gateway = in.Gateway
        out.System = in.System
        out.SecretRef = (*corev1.SecretReference)(unsafe.Pointer(in.SecretRef))
        out.SSLEnabled = in.SSLEnabled
        out.ProtectionDomain = in.ProtectionDomain
        out.StoragePool = in.StoragePool
        out.StorageMode = in.StorageMode
        out.VolumeName = in.VolumeName
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_ScaleIOPersistentVolumeSource_To_v1_ScaleIOPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_ScaleIOPersistentVolumeSource_To_v1_ScaleIOPersistentVolumeSource(in *core.ScaleIOPersistentVolumeSource, out *corev1.ScaleIOPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_ScaleIOPersistentVolumeSource_To_v1_ScaleIOPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_ScaleIOVolumeSource_To_core_ScaleIOVolumeSource(in *corev1.ScaleIOVolumeSource, out *core.ScaleIOVolumeSource, s conversion.Scope) error {
        out.Gateway = in.Gateway
        out.System = in.System
        out.SecretRef = (*core.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.SSLEnabled = in.SSLEnabled
        out.ProtectionDomain = in.ProtectionDomain
        out.StoragePool = in.StoragePool
        out.StorageMode = in.StorageMode
        out.VolumeName = in.VolumeName
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_v1_ScaleIOVolumeSource_To_core_ScaleIOVolumeSource is an autogenerated conversion function.
func Convert_v1_ScaleIOVolumeSource_To_core_ScaleIOVolumeSource(in *corev1.ScaleIOVolumeSource, out *core.ScaleIOVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_ScaleIOVolumeSource_To_core_ScaleIOVolumeSource(in, out, s)
}

func autoConvert_core_ScaleIOVolumeSource_To_v1_ScaleIOVolumeSource(in *core.ScaleIOVolumeSource, out *corev1.ScaleIOVolumeSource, s conversion.Scope) error {
        out.Gateway = in.Gateway
        out.System = in.System
        out.SecretRef = (*corev1.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        out.SSLEnabled = in.SSLEnabled
        out.ProtectionDomain = in.ProtectionDomain
        out.StoragePool = in.StoragePool
        out.StorageMode = in.StorageMode
        out.VolumeName = in.VolumeName
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        return nil
}

// Convert_core_ScaleIOVolumeSource_To_v1_ScaleIOVolumeSource is an autogenerated conversion function.
func Convert_core_ScaleIOVolumeSource_To_v1_ScaleIOVolumeSource(in *core.ScaleIOVolumeSource, out *corev1.ScaleIOVolumeSource, s conversion.Scope) error {
        return autoConvert_core_ScaleIOVolumeSource_To_v1_ScaleIOVolumeSource(in, out, s)
}

func autoConvert_v1_ScopeSelector_To_core_ScopeSelector(in *corev1.ScopeSelector, out *core.ScopeSelector, s conversion.Scope) error {
        out.MatchExpressions = *(*[]core.ScopedResourceSelectorRequirement)(unsafe.Pointer(&in.MatchExpressions))
        return nil
}

// Convert_v1_ScopeSelector_To_core_ScopeSelector is an autogenerated conversion function.
func Convert_v1_ScopeSelector_To_core_ScopeSelector(in *corev1.ScopeSelector, out *core.ScopeSelector, s conversion.Scope) error {
        return autoConvert_v1_ScopeSelector_To_core_ScopeSelector(in, out, s)
}

func autoConvert_core_ScopeSelector_To_v1_ScopeSelector(in *core.ScopeSelector, out *corev1.ScopeSelector, s conversion.Scope) error {
        out.MatchExpressions = *(*[]corev1.ScopedResourceSelectorRequirement)(unsafe.Pointer(&in.MatchExpressions))
        return nil
}

// Convert_core_ScopeSelector_To_v1_ScopeSelector is an autogenerated conversion function.
func Convert_core_ScopeSelector_To_v1_ScopeSelector(in *core.ScopeSelector, out *corev1.ScopeSelector, s conversion.Scope) error {
        return autoConvert_core_ScopeSelector_To_v1_ScopeSelector(in, out, s)
}

func autoConvert_v1_ScopedResourceSelectorRequirement_To_core_ScopedResourceSelectorRequirement(in *corev1.ScopedResourceSelectorRequirement, out *core.ScopedResourceSelectorRequirement, s conversion.Scope) error {
        out.ScopeName = core.ResourceQuotaScope(in.ScopeName)
        out.Operator = core.ScopeSelectorOperator(in.Operator)
        out.Values = *(*[]string)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_v1_ScopedResourceSelectorRequirement_To_core_ScopedResourceSelectorRequirement is an autogenerated conversion function.
func Convert_v1_ScopedResourceSelectorRequirement_To_core_ScopedResourceSelectorRequirement(in *corev1.ScopedResourceSelectorRequirement, out *core.ScopedResourceSelectorRequirement, s conversion.Scope) error {
        return autoConvert_v1_ScopedResourceSelectorRequirement_To_core_ScopedResourceSelectorRequirement(in, out, s)
}

func autoConvert_core_ScopedResourceSelectorRequirement_To_v1_ScopedResourceSelectorRequirement(in *core.ScopedResourceSelectorRequirement, out *corev1.ScopedResourceSelectorRequirement, s conversion.Scope) error {
        out.ScopeName = corev1.ResourceQuotaScope(in.ScopeName)
        out.Operator = corev1.ScopeSelectorOperator(in.Operator)
        out.Values = *(*[]string)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_core_ScopedResourceSelectorRequirement_To_v1_ScopedResourceSelectorRequirement is an autogenerated conversion function.
func Convert_core_ScopedResourceSelectorRequirement_To_v1_ScopedResourceSelectorRequirement(in *core.ScopedResourceSelectorRequirement, out *corev1.ScopedResourceSelectorRequirement, s conversion.Scope) error {
        return autoConvert_core_ScopedResourceSelectorRequirement_To_v1_ScopedResourceSelectorRequirement(in, out, s)
}

func autoConvert_v1_SeccompProfile_To_core_SeccompProfile(in *corev1.SeccompProfile, out *core.SeccompProfile, s conversion.Scope) error {
        out.Type = core.SeccompProfileType(in.Type)
        out.LocalhostProfile = (*string)(unsafe.Pointer(in.LocalhostProfile))
        return nil
}

// Convert_v1_SeccompProfile_To_core_SeccompProfile is an autogenerated conversion function.
func Convert_v1_SeccompProfile_To_core_SeccompProfile(in *corev1.SeccompProfile, out *core.SeccompProfile, s conversion.Scope) error {
        return autoConvert_v1_SeccompProfile_To_core_SeccompProfile(in, out, s)
}

func autoConvert_core_SeccompProfile_To_v1_SeccompProfile(in *core.SeccompProfile, out *corev1.SeccompProfile, s conversion.Scope) error {
        out.Type = corev1.SeccompProfileType(in.Type)
        out.LocalhostProfile = (*string)(unsafe.Pointer(in.LocalhostProfile))
        return nil
}

// Convert_core_SeccompProfile_To_v1_SeccompProfile is an autogenerated conversion function.
func Convert_core_SeccompProfile_To_v1_SeccompProfile(in *core.SeccompProfile, out *corev1.SeccompProfile, s conversion.Scope) error {
        return autoConvert_core_SeccompProfile_To_v1_SeccompProfile(in, out, s)
}

func autoConvert_v1_Secret_To_core_Secret(in *corev1.Secret, out *core.Secret, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Immutable = (*bool)(unsafe.Pointer(in.Immutable))
        out.Data = *(*map[string][]byte)(unsafe.Pointer(&in.Data))
        // INFO: in.StringData opted out of conversion generation
        out.Type = core.SecretType(in.Type)
        return nil
}

func autoConvert_core_Secret_To_v1_Secret(in *core.Secret, out *corev1.Secret, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Immutable = (*bool)(unsafe.Pointer(in.Immutable))
        out.Data = *(*map[string][]byte)(unsafe.Pointer(&in.Data))
        out.Type = corev1.SecretType(in.Type)
        return nil
}

// Convert_core_Secret_To_v1_Secret is an autogenerated conversion function.
func Convert_core_Secret_To_v1_Secret(in *core.Secret, out *corev1.Secret, s conversion.Scope) error {
        return autoConvert_core_Secret_To_v1_Secret(in, out, s)
}

func autoConvert_v1_SecretEnvSource_To_core_SecretEnvSource(in *corev1.SecretEnvSource, out *core.SecretEnvSource, s conversion.Scope) error {
        if err := Convert_v1_LocalObjectReference_To_core_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_SecretEnvSource_To_core_SecretEnvSource is an autogenerated conversion function.
func Convert_v1_SecretEnvSource_To_core_SecretEnvSource(in *corev1.SecretEnvSource, out *core.SecretEnvSource, s conversion.Scope) error {
        return autoConvert_v1_SecretEnvSource_To_core_SecretEnvSource(in, out, s)
}

func autoConvert_core_SecretEnvSource_To_v1_SecretEnvSource(in *core.SecretEnvSource, out *corev1.SecretEnvSource, s conversion.Scope) error {
        if err := Convert_core_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_SecretEnvSource_To_v1_SecretEnvSource is an autogenerated conversion function.
func Convert_core_SecretEnvSource_To_v1_SecretEnvSource(in *core.SecretEnvSource, out *corev1.SecretEnvSource, s conversion.Scope) error {
        return autoConvert_core_SecretEnvSource_To_v1_SecretEnvSource(in, out, s)
}

func autoConvert_v1_SecretKeySelector_To_core_SecretKeySelector(in *corev1.SecretKeySelector, out *core.SecretKeySelector, s conversion.Scope) error {
        if err := Convert_v1_LocalObjectReference_To_core_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Key = in.Key
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_SecretKeySelector_To_core_SecretKeySelector is an autogenerated conversion function.
func Convert_v1_SecretKeySelector_To_core_SecretKeySelector(in *corev1.SecretKeySelector, out *core.SecretKeySelector, s conversion.Scope) error {
        return autoConvert_v1_SecretKeySelector_To_core_SecretKeySelector(in, out, s)
}

func autoConvert_core_SecretKeySelector_To_v1_SecretKeySelector(in *core.SecretKeySelector, out *corev1.SecretKeySelector, s conversion.Scope) error {
        if err := Convert_core_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Key = in.Key
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_SecretKeySelector_To_v1_SecretKeySelector is an autogenerated conversion function.
func Convert_core_SecretKeySelector_To_v1_SecretKeySelector(in *core.SecretKeySelector, out *corev1.SecretKeySelector, s conversion.Scope) error {
        return autoConvert_core_SecretKeySelector_To_v1_SecretKeySelector(in, out, s)
}

func autoConvert_v1_SecretList_To_core_SecretList(in *corev1.SecretList, out *core.SecretList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.Secret, len(*in))
                for i := range *in {
                        if err := Convert_v1_Secret_To_core_Secret(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_SecretList_To_core_SecretList is an autogenerated conversion function.
func Convert_v1_SecretList_To_core_SecretList(in *corev1.SecretList, out *core.SecretList, s conversion.Scope) error {
        return autoConvert_v1_SecretList_To_core_SecretList(in, out, s)
}

func autoConvert_core_SecretList_To_v1_SecretList(in *core.SecretList, out *corev1.SecretList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]corev1.Secret, len(*in))
                for i := range *in {
                        if err := Convert_core_Secret_To_v1_Secret(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_SecretList_To_v1_SecretList is an autogenerated conversion function.
func Convert_core_SecretList_To_v1_SecretList(in *core.SecretList, out *corev1.SecretList, s conversion.Scope) error {
        return autoConvert_core_SecretList_To_v1_SecretList(in, out, s)
}

func autoConvert_v1_SecretProjection_To_core_SecretProjection(in *corev1.SecretProjection, out *core.SecretProjection, s conversion.Scope) error {
        if err := Convert_v1_LocalObjectReference_To_core_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Items = *(*[]core.KeyToPath)(unsafe.Pointer(&in.Items))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_SecretProjection_To_core_SecretProjection is an autogenerated conversion function.
func Convert_v1_SecretProjection_To_core_SecretProjection(in *corev1.SecretProjection, out *core.SecretProjection, s conversion.Scope) error {
        return autoConvert_v1_SecretProjection_To_core_SecretProjection(in, out, s)
}

func autoConvert_core_SecretProjection_To_v1_SecretProjection(in *core.SecretProjection, out *corev1.SecretProjection, s conversion.Scope) error {
        if err := Convert_core_LocalObjectReference_To_v1_LocalObjectReference(&in.LocalObjectReference, &out.LocalObjectReference, s); err != nil {
                return err
        }
        out.Items = *(*[]corev1.KeyToPath)(unsafe.Pointer(&in.Items))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_SecretProjection_To_v1_SecretProjection is an autogenerated conversion function.
func Convert_core_SecretProjection_To_v1_SecretProjection(in *core.SecretProjection, out *corev1.SecretProjection, s conversion.Scope) error {
        return autoConvert_core_SecretProjection_To_v1_SecretProjection(in, out, s)
}

func autoConvert_v1_SecretReference_To_core_SecretReference(in *corev1.SecretReference, out *core.SecretReference, s conversion.Scope) error {
        out.Name = in.Name
        out.Namespace = in.Namespace
        return nil
}

// Convert_v1_SecretReference_To_core_SecretReference is an autogenerated conversion function.
func Convert_v1_SecretReference_To_core_SecretReference(in *corev1.SecretReference, out *core.SecretReference, s conversion.Scope) error {
        return autoConvert_v1_SecretReference_To_core_SecretReference(in, out, s)
}

func autoConvert_core_SecretReference_To_v1_SecretReference(in *core.SecretReference, out *corev1.SecretReference, s conversion.Scope) error {
        out.Name = in.Name
        out.Namespace = in.Namespace
        return nil
}

// Convert_core_SecretReference_To_v1_SecretReference is an autogenerated conversion function.
func Convert_core_SecretReference_To_v1_SecretReference(in *core.SecretReference, out *corev1.SecretReference, s conversion.Scope) error {
        return autoConvert_core_SecretReference_To_v1_SecretReference(in, out, s)
}

func autoConvert_v1_SecretVolumeSource_To_core_SecretVolumeSource(in *corev1.SecretVolumeSource, out *core.SecretVolumeSource, s conversion.Scope) error {
        out.SecretName = in.SecretName
        out.Items = *(*[]core.KeyToPath)(unsafe.Pointer(&in.Items))
        out.DefaultMode = (*int32)(unsafe.Pointer(in.DefaultMode))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_v1_SecretVolumeSource_To_core_SecretVolumeSource is an autogenerated conversion function.
func Convert_v1_SecretVolumeSource_To_core_SecretVolumeSource(in *corev1.SecretVolumeSource, out *core.SecretVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_SecretVolumeSource_To_core_SecretVolumeSource(in, out, s)
}

func autoConvert_core_SecretVolumeSource_To_v1_SecretVolumeSource(in *core.SecretVolumeSource, out *corev1.SecretVolumeSource, s conversion.Scope) error {
        out.SecretName = in.SecretName
        out.Items = *(*[]corev1.KeyToPath)(unsafe.Pointer(&in.Items))
        out.DefaultMode = (*int32)(unsafe.Pointer(in.DefaultMode))
        out.Optional = (*bool)(unsafe.Pointer(in.Optional))
        return nil
}

// Convert_core_SecretVolumeSource_To_v1_SecretVolumeSource is an autogenerated conversion function.
func Convert_core_SecretVolumeSource_To_v1_SecretVolumeSource(in *core.SecretVolumeSource, out *corev1.SecretVolumeSource, s conversion.Scope) error {
        return autoConvert_core_SecretVolumeSource_To_v1_SecretVolumeSource(in, out, s)
}

func autoConvert_v1_SecurityContext_To_core_SecurityContext(in *corev1.SecurityContext, out *core.SecurityContext, s conversion.Scope) error {
        out.Capabilities = (*core.Capabilities)(unsafe.Pointer(in.Capabilities))
        out.Privileged = (*bool)(unsafe.Pointer(in.Privileged))
        out.SELinuxOptions = (*core.SELinuxOptions)(unsafe.Pointer(in.SELinuxOptions))
        out.WindowsOptions = (*core.WindowsSecurityContextOptions)(unsafe.Pointer(in.WindowsOptions))
        out.RunAsUser = (*int64)(unsafe.Pointer(in.RunAsUser))
        out.RunAsGroup = (*int64)(unsafe.Pointer(in.RunAsGroup))
        out.RunAsNonRoot = (*bool)(unsafe.Pointer(in.RunAsNonRoot))
        out.ReadOnlyRootFilesystem = (*bool)(unsafe.Pointer(in.ReadOnlyRootFilesystem))
        out.AllowPrivilegeEscalation = (*bool)(unsafe.Pointer(in.AllowPrivilegeEscalation))
        out.ProcMount = (*core.ProcMountType)(unsafe.Pointer(in.ProcMount))
        out.SeccompProfile = (*core.SeccompProfile)(unsafe.Pointer(in.SeccompProfile))
        out.AppArmorProfile = (*core.AppArmorProfile)(unsafe.Pointer(in.AppArmorProfile))
        return nil
}

// Convert_v1_SecurityContext_To_core_SecurityContext is an autogenerated conversion function.
func Convert_v1_SecurityContext_To_core_SecurityContext(in *corev1.SecurityContext, out *core.SecurityContext, s conversion.Scope) error {
        return autoConvert_v1_SecurityContext_To_core_SecurityContext(in, out, s)
}

func autoConvert_core_SecurityContext_To_v1_SecurityContext(in *core.SecurityContext, out *corev1.SecurityContext, s conversion.Scope) error {
        out.Capabilities = (*corev1.Capabilities)(unsafe.Pointer(in.Capabilities))
        out.Privileged = (*bool)(unsafe.Pointer(in.Privileged))
        out.SELinuxOptions = (*corev1.SELinuxOptions)(unsafe.Pointer(in.SELinuxOptions))
        out.WindowsOptions = (*corev1.WindowsSecurityContextOptions)(unsafe.Pointer(in.WindowsOptions))
        out.RunAsUser = (*int64)(unsafe.Pointer(in.RunAsUser))
        out.RunAsGroup = (*int64)(unsafe.Pointer(in.RunAsGroup))
        out.RunAsNonRoot = (*bool)(unsafe.Pointer(in.RunAsNonRoot))
        out.ReadOnlyRootFilesystem = (*bool)(unsafe.Pointer(in.ReadOnlyRootFilesystem))
        out.AllowPrivilegeEscalation = (*bool)(unsafe.Pointer(in.AllowPrivilegeEscalation))
        out.ProcMount = (*corev1.ProcMountType)(unsafe.Pointer(in.ProcMount))
        out.SeccompProfile = (*corev1.SeccompProfile)(unsafe.Pointer(in.SeccompProfile))
        out.AppArmorProfile = (*corev1.AppArmorProfile)(unsafe.Pointer(in.AppArmorProfile))
        return nil
}

// Convert_core_SecurityContext_To_v1_SecurityContext is an autogenerated conversion function.
func Convert_core_SecurityContext_To_v1_SecurityContext(in *core.SecurityContext, out *corev1.SecurityContext, s conversion.Scope) error {
        return autoConvert_core_SecurityContext_To_v1_SecurityContext(in, out, s)
}

func autoConvert_v1_SerializedReference_To_core_SerializedReference(in *corev1.SerializedReference, out *core.SerializedReference, s conversion.Scope) error {
        if err := Convert_v1_ObjectReference_To_core_ObjectReference(&in.Reference, &out.Reference, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_SerializedReference_To_core_SerializedReference is an autogenerated conversion function.
func Convert_v1_SerializedReference_To_core_SerializedReference(in *corev1.SerializedReference, out *core.SerializedReference, s conversion.Scope) error {
        return autoConvert_v1_SerializedReference_To_core_SerializedReference(in, out, s)
}

func autoConvert_core_SerializedReference_To_v1_SerializedReference(in *core.SerializedReference, out *corev1.SerializedReference, s conversion.Scope) error {
        if err := Convert_core_ObjectReference_To_v1_ObjectReference(&in.Reference, &out.Reference, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_SerializedReference_To_v1_SerializedReference is an autogenerated conversion function.
func Convert_core_SerializedReference_To_v1_SerializedReference(in *core.SerializedReference, out *corev1.SerializedReference, s conversion.Scope) error {
        return autoConvert_core_SerializedReference_To_v1_SerializedReference(in, out, s)
}

func autoConvert_v1_Service_To_core_Service(in *corev1.Service, out *core.Service, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_ServiceSpec_To_core_ServiceSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_ServiceStatus_To_core_ServiceStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_Service_To_core_Service is an autogenerated conversion function.
func Convert_v1_Service_To_core_Service(in *corev1.Service, out *core.Service, s conversion.Scope) error {
        return autoConvert_v1_Service_To_core_Service(in, out, s)
}

func autoConvert_core_Service_To_v1_Service(in *core.Service, out *corev1.Service, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_core_ServiceSpec_To_v1_ServiceSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_core_ServiceStatus_To_v1_ServiceStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_Service_To_v1_Service is an autogenerated conversion function.
func Convert_core_Service_To_v1_Service(in *core.Service, out *corev1.Service, s conversion.Scope) error {
        return autoConvert_core_Service_To_v1_Service(in, out, s)
}

func autoConvert_v1_ServiceAccount_To_core_ServiceAccount(in *corev1.ServiceAccount, out *core.ServiceAccount, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Secrets = *(*[]core.ObjectReference)(unsafe.Pointer(&in.Secrets))
        out.ImagePullSecrets = *(*[]core.LocalObjectReference)(unsafe.Pointer(&in.ImagePullSecrets))
        out.AutomountServiceAccountToken = (*bool)(unsafe.Pointer(in.AutomountServiceAccountToken))
        return nil
}

// Convert_v1_ServiceAccount_To_core_ServiceAccount is an autogenerated conversion function.
func Convert_v1_ServiceAccount_To_core_ServiceAccount(in *corev1.ServiceAccount, out *core.ServiceAccount, s conversion.Scope) error {
        return autoConvert_v1_ServiceAccount_To_core_ServiceAccount(in, out, s)
}

func autoConvert_core_ServiceAccount_To_v1_ServiceAccount(in *core.ServiceAccount, out *corev1.ServiceAccount, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.Secrets = *(*[]corev1.ObjectReference)(unsafe.Pointer(&in.Secrets))
        out.ImagePullSecrets = *(*[]corev1.LocalObjectReference)(unsafe.Pointer(&in.ImagePullSecrets))
        out.AutomountServiceAccountToken = (*bool)(unsafe.Pointer(in.AutomountServiceAccountToken))
        return nil
}

// Convert_core_ServiceAccount_To_v1_ServiceAccount is an autogenerated conversion function.
func Convert_core_ServiceAccount_To_v1_ServiceAccount(in *core.ServiceAccount, out *corev1.ServiceAccount, s conversion.Scope) error {
        return autoConvert_core_ServiceAccount_To_v1_ServiceAccount(in, out, s)
}

func autoConvert_v1_ServiceAccountList_To_core_ServiceAccountList(in *corev1.ServiceAccountList, out *core.ServiceAccountList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]core.ServiceAccount)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_ServiceAccountList_To_core_ServiceAccountList is an autogenerated conversion function.
func Convert_v1_ServiceAccountList_To_core_ServiceAccountList(in *corev1.ServiceAccountList, out *core.ServiceAccountList, s conversion.Scope) error {
        return autoConvert_v1_ServiceAccountList_To_core_ServiceAccountList(in, out, s)
}

func autoConvert_core_ServiceAccountList_To_v1_ServiceAccountList(in *core.ServiceAccountList, out *corev1.ServiceAccountList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]corev1.ServiceAccount)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_core_ServiceAccountList_To_v1_ServiceAccountList is an autogenerated conversion function.
func Convert_core_ServiceAccountList_To_v1_ServiceAccountList(in *core.ServiceAccountList, out *corev1.ServiceAccountList, s conversion.Scope) error {
        return autoConvert_core_ServiceAccountList_To_v1_ServiceAccountList(in, out, s)
}

func autoConvert_v1_ServiceAccountTokenProjection_To_core_ServiceAccountTokenProjection(in *corev1.ServiceAccountTokenProjection, out *core.ServiceAccountTokenProjection, s conversion.Scope) error {
        out.Audience = in.Audience
        if err := metav1.Convert_Pointer_int64_To_int64(&in.ExpirationSeconds, &out.ExpirationSeconds, s); err != nil {
                return err
        }
        out.Path = in.Path
        return nil
}

// Convert_v1_ServiceAccountTokenProjection_To_core_ServiceAccountTokenProjection is an autogenerated conversion function.
func Convert_v1_ServiceAccountTokenProjection_To_core_ServiceAccountTokenProjection(in *corev1.ServiceAccountTokenProjection, out *core.ServiceAccountTokenProjection, s conversion.Scope) error {
        return autoConvert_v1_ServiceAccountTokenProjection_To_core_ServiceAccountTokenProjection(in, out, s)
}

func autoConvert_core_ServiceAccountTokenProjection_To_v1_ServiceAccountTokenProjection(in *core.ServiceAccountTokenProjection, out *corev1.ServiceAccountTokenProjection, s conversion.Scope) error {
        out.Audience = in.Audience
        if err := metav1.Convert_int64_To_Pointer_int64(&in.ExpirationSeconds, &out.ExpirationSeconds, s); err != nil {
                return err
        }
        out.Path = in.Path
        return nil
}

// Convert_core_ServiceAccountTokenProjection_To_v1_ServiceAccountTokenProjection is an autogenerated conversion function.
func Convert_core_ServiceAccountTokenProjection_To_v1_ServiceAccountTokenProjection(in *core.ServiceAccountTokenProjection, out *corev1.ServiceAccountTokenProjection, s conversion.Scope) error {
        return autoConvert_core_ServiceAccountTokenProjection_To_v1_ServiceAccountTokenProjection(in, out, s)
}

func autoConvert_v1_ServiceList_To_core_ServiceList(in *corev1.ServiceList, out *core.ServiceList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.Service, len(*in))
                for i := range *in {
                        if err := Convert_v1_Service_To_core_Service(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_ServiceList_To_core_ServiceList is an autogenerated conversion function.
func Convert_v1_ServiceList_To_core_ServiceList(in *corev1.ServiceList, out *core.ServiceList, s conversion.Scope) error {
        return autoConvert_v1_ServiceList_To_core_ServiceList(in, out, s)
}

func autoConvert_core_ServiceList_To_v1_ServiceList(in *core.ServiceList, out *corev1.ServiceList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]corev1.Service, len(*in))
                for i := range *in {
                        if err := Convert_core_Service_To_v1_Service(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_ServiceList_To_v1_ServiceList is an autogenerated conversion function.
func Convert_core_ServiceList_To_v1_ServiceList(in *core.ServiceList, out *corev1.ServiceList, s conversion.Scope) error {
        return autoConvert_core_ServiceList_To_v1_ServiceList(in, out, s)
}

func autoConvert_v1_ServicePort_To_core_ServicePort(in *corev1.ServicePort, out *core.ServicePort, s conversion.Scope) error {
        out.Name = in.Name
        out.Protocol = core.Protocol(in.Protocol)
        out.AppProtocol = (*string)(unsafe.Pointer(in.AppProtocol))
        out.Port = in.Port
        out.TargetPort = in.TargetPort
        out.NodePort = in.NodePort
        return nil
}

// Convert_v1_ServicePort_To_core_ServicePort is an autogenerated conversion function.
func Convert_v1_ServicePort_To_core_ServicePort(in *corev1.ServicePort, out *core.ServicePort, s conversion.Scope) error {
        return autoConvert_v1_ServicePort_To_core_ServicePort(in, out, s)
}

func autoConvert_core_ServicePort_To_v1_ServicePort(in *core.ServicePort, out *corev1.ServicePort, s conversion.Scope) error {
        out.Name = in.Name
        out.Protocol = corev1.Protocol(in.Protocol)
        out.AppProtocol = (*string)(unsafe.Pointer(in.AppProtocol))
        out.Port = in.Port
        out.TargetPort = in.TargetPort
        out.NodePort = in.NodePort
        return nil
}

// Convert_core_ServicePort_To_v1_ServicePort is an autogenerated conversion function.
func Convert_core_ServicePort_To_v1_ServicePort(in *core.ServicePort, out *corev1.ServicePort, s conversion.Scope) error {
        return autoConvert_core_ServicePort_To_v1_ServicePort(in, out, s)
}

func autoConvert_v1_ServiceProxyOptions_To_core_ServiceProxyOptions(in *corev1.ServiceProxyOptions, out *core.ServiceProxyOptions, s conversion.Scope) error {
        out.Path = in.Path
        return nil
}

// Convert_v1_ServiceProxyOptions_To_core_ServiceProxyOptions is an autogenerated conversion function.
func Convert_v1_ServiceProxyOptions_To_core_ServiceProxyOptions(in *corev1.ServiceProxyOptions, out *core.ServiceProxyOptions, s conversion.Scope) error {
        return autoConvert_v1_ServiceProxyOptions_To_core_ServiceProxyOptions(in, out, s)
}

func autoConvert_core_ServiceProxyOptions_To_v1_ServiceProxyOptions(in *core.ServiceProxyOptions, out *corev1.ServiceProxyOptions, s conversion.Scope) error {
        out.Path = in.Path
        return nil
}

// Convert_core_ServiceProxyOptions_To_v1_ServiceProxyOptions is an autogenerated conversion function.
func Convert_core_ServiceProxyOptions_To_v1_ServiceProxyOptions(in *core.ServiceProxyOptions, out *corev1.ServiceProxyOptions, s conversion.Scope) error {
        return autoConvert_core_ServiceProxyOptions_To_v1_ServiceProxyOptions(in, out, s)
}

func autoConvert_url_Values_To_v1_ServiceProxyOptions(in *url.Values, out *corev1.ServiceProxyOptions, s conversion.Scope) error {
        // WARNING: Field TypeMeta does not have json tag, skipping.

        if values, ok := map[string][]string(*in)["path"]; ok && len(values) > 0 {
                if err := runtime.Convert_Slice_string_To_string(&values, &out.Path, s); err != nil {
                        return err
                }
        } else {
                out.Path = ""
        }
        return nil
}

// Convert_url_Values_To_v1_ServiceProxyOptions is an autogenerated conversion function.
func Convert_url_Values_To_v1_ServiceProxyOptions(in *url.Values, out *corev1.ServiceProxyOptions, s conversion.Scope) error {
        return autoConvert_url_Values_To_v1_ServiceProxyOptions(in, out, s)
}

func autoConvert_v1_ServiceSpec_To_core_ServiceSpec(in *corev1.ServiceSpec, out *core.ServiceSpec, s conversion.Scope) error {
        out.Ports = *(*[]core.ServicePort)(unsafe.Pointer(&in.Ports))
        out.Selector = *(*map[string]string)(unsafe.Pointer(&in.Selector))
        out.ClusterIP = in.ClusterIP
        out.ClusterIPs = *(*[]string)(unsafe.Pointer(&in.ClusterIPs))
        out.Type = core.ServiceType(in.Type)
        out.ExternalIPs = *(*[]string)(unsafe.Pointer(&in.ExternalIPs))
        out.SessionAffinity = core.ServiceAffinity(in.SessionAffinity)
        out.LoadBalancerIP = in.LoadBalancerIP
        out.LoadBalancerSourceRanges = *(*[]string)(unsafe.Pointer(&in.LoadBalancerSourceRanges))
        out.ExternalName = in.ExternalName
        out.ExternalTrafficPolicy = core.ServiceExternalTrafficPolicy(in.ExternalTrafficPolicy)
        out.HealthCheckNodePort = in.HealthCheckNodePort
        out.PublishNotReadyAddresses = in.PublishNotReadyAddresses
        out.SessionAffinityConfig = (*core.SessionAffinityConfig)(unsafe.Pointer(in.SessionAffinityConfig))
        out.IPFamilies = *(*[]core.IPFamily)(unsafe.Pointer(&in.IPFamilies))
        out.IPFamilyPolicy = (*core.IPFamilyPolicy)(unsafe.Pointer(in.IPFamilyPolicy))
        out.AllocateLoadBalancerNodePorts = (*bool)(unsafe.Pointer(in.AllocateLoadBalancerNodePorts))
        out.LoadBalancerClass = (*string)(unsafe.Pointer(in.LoadBalancerClass))
        out.InternalTrafficPolicy = (*core.ServiceInternalTrafficPolicy)(unsafe.Pointer(in.InternalTrafficPolicy))
        out.TrafficDistribution = (*string)(unsafe.Pointer(in.TrafficDistribution))
        return nil
}

// Convert_v1_ServiceSpec_To_core_ServiceSpec is an autogenerated conversion function.
func Convert_v1_ServiceSpec_To_core_ServiceSpec(in *corev1.ServiceSpec, out *core.ServiceSpec, s conversion.Scope) error {
        return autoConvert_v1_ServiceSpec_To_core_ServiceSpec(in, out, s)
}

func autoConvert_core_ServiceSpec_To_v1_ServiceSpec(in *core.ServiceSpec, out *corev1.ServiceSpec, s conversion.Scope) error {
        out.Type = corev1.ServiceType(in.Type)
        out.Ports = *(*[]corev1.ServicePort)(unsafe.Pointer(&in.Ports))
        out.Selector = *(*map[string]string)(unsafe.Pointer(&in.Selector))
        out.ClusterIP = in.ClusterIP
        out.ClusterIPs = *(*[]string)(unsafe.Pointer(&in.ClusterIPs))
        out.IPFamilies = *(*[]corev1.IPFamily)(unsafe.Pointer(&in.IPFamilies))
        out.IPFamilyPolicy = (*corev1.IPFamilyPolicy)(unsafe.Pointer(in.IPFamilyPolicy))
        out.ExternalName = in.ExternalName
        out.ExternalIPs = *(*[]string)(unsafe.Pointer(&in.ExternalIPs))
        out.LoadBalancerIP = in.LoadBalancerIP
        out.SessionAffinity = corev1.ServiceAffinity(in.SessionAffinity)
        out.SessionAffinityConfig = (*corev1.SessionAffinityConfig)(unsafe.Pointer(in.SessionAffinityConfig))
        out.LoadBalancerSourceRanges = *(*[]string)(unsafe.Pointer(&in.LoadBalancerSourceRanges))
        out.ExternalTrafficPolicy = corev1.ServiceExternalTrafficPolicy(in.ExternalTrafficPolicy)
        out.HealthCheckNodePort = in.HealthCheckNodePort
        out.PublishNotReadyAddresses = in.PublishNotReadyAddresses
        out.AllocateLoadBalancerNodePorts = (*bool)(unsafe.Pointer(in.AllocateLoadBalancerNodePorts))
        out.LoadBalancerClass = (*string)(unsafe.Pointer(in.LoadBalancerClass))
        out.InternalTrafficPolicy = (*corev1.ServiceInternalTrafficPolicy)(unsafe.Pointer(in.InternalTrafficPolicy))
        out.TrafficDistribution = (*string)(unsafe.Pointer(in.TrafficDistribution))
        return nil
}

// Convert_core_ServiceSpec_To_v1_ServiceSpec is an autogenerated conversion function.
func Convert_core_ServiceSpec_To_v1_ServiceSpec(in *core.ServiceSpec, out *corev1.ServiceSpec, s conversion.Scope) error {
        return autoConvert_core_ServiceSpec_To_v1_ServiceSpec(in, out, s)
}

func autoConvert_v1_ServiceStatus_To_core_ServiceStatus(in *corev1.ServiceStatus, out *core.ServiceStatus, s conversion.Scope) error {
        if err := Convert_v1_LoadBalancerStatus_To_core_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
                return err
        }
        out.Conditions = *(*[]metav1.Condition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1_ServiceStatus_To_core_ServiceStatus is an autogenerated conversion function.
func Convert_v1_ServiceStatus_To_core_ServiceStatus(in *corev1.ServiceStatus, out *core.ServiceStatus, s conversion.Scope) error {
        return autoConvert_v1_ServiceStatus_To_core_ServiceStatus(in, out, s)
}

func autoConvert_core_ServiceStatus_To_v1_ServiceStatus(in *core.ServiceStatus, out *corev1.ServiceStatus, s conversion.Scope) error {
        if err := Convert_core_LoadBalancerStatus_To_v1_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
                return err
        }
        out.Conditions = *(*[]metav1.Condition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_core_ServiceStatus_To_v1_ServiceStatus is an autogenerated conversion function.
func Convert_core_ServiceStatus_To_v1_ServiceStatus(in *core.ServiceStatus, out *corev1.ServiceStatus, s conversion.Scope) error {
        return autoConvert_core_ServiceStatus_To_v1_ServiceStatus(in, out, s)
}

func autoConvert_v1_SessionAffinityConfig_To_core_SessionAffinityConfig(in *corev1.SessionAffinityConfig, out *core.SessionAffinityConfig, s conversion.Scope) error {
        out.ClientIP = (*core.ClientIPConfig)(unsafe.Pointer(in.ClientIP))
        return nil
}

// Convert_v1_SessionAffinityConfig_To_core_SessionAffinityConfig is an autogenerated conversion function.
func Convert_v1_SessionAffinityConfig_To_core_SessionAffinityConfig(in *corev1.SessionAffinityConfig, out *core.SessionAffinityConfig, s conversion.Scope) error {
        return autoConvert_v1_SessionAffinityConfig_To_core_SessionAffinityConfig(in, out, s)
}

func autoConvert_core_SessionAffinityConfig_To_v1_SessionAffinityConfig(in *core.SessionAffinityConfig, out *corev1.SessionAffinityConfig, s conversion.Scope) error {
        out.ClientIP = (*corev1.ClientIPConfig)(unsafe.Pointer(in.ClientIP))
        return nil
}

// Convert_core_SessionAffinityConfig_To_v1_SessionAffinityConfig is an autogenerated conversion function.
func Convert_core_SessionAffinityConfig_To_v1_SessionAffinityConfig(in *core.SessionAffinityConfig, out *corev1.SessionAffinityConfig, s conversion.Scope) error {
        return autoConvert_core_SessionAffinityConfig_To_v1_SessionAffinityConfig(in, out, s)
}

func autoConvert_v1_SleepAction_To_core_SleepAction(in *corev1.SleepAction, out *core.SleepAction, s conversion.Scope) error {
        out.Seconds = in.Seconds
        return nil
}

// Convert_v1_SleepAction_To_core_SleepAction is an autogenerated conversion function.
func Convert_v1_SleepAction_To_core_SleepAction(in *corev1.SleepAction, out *core.SleepAction, s conversion.Scope) error {
        return autoConvert_v1_SleepAction_To_core_SleepAction(in, out, s)
}

func autoConvert_core_SleepAction_To_v1_SleepAction(in *core.SleepAction, out *corev1.SleepAction, s conversion.Scope) error {
        out.Seconds = in.Seconds
        return nil
}

// Convert_core_SleepAction_To_v1_SleepAction is an autogenerated conversion function.
func Convert_core_SleepAction_To_v1_SleepAction(in *core.SleepAction, out *corev1.SleepAction, s conversion.Scope) error {
        return autoConvert_core_SleepAction_To_v1_SleepAction(in, out, s)
}

func autoConvert_v1_StorageOSPersistentVolumeSource_To_core_StorageOSPersistentVolumeSource(in *corev1.StorageOSPersistentVolumeSource, out *core.StorageOSPersistentVolumeSource, s conversion.Scope) error {
        out.VolumeName = in.VolumeName
        out.VolumeNamespace = in.VolumeNamespace
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.SecretRef = (*core.ObjectReference)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_v1_StorageOSPersistentVolumeSource_To_core_StorageOSPersistentVolumeSource is an autogenerated conversion function.
func Convert_v1_StorageOSPersistentVolumeSource_To_core_StorageOSPersistentVolumeSource(in *corev1.StorageOSPersistentVolumeSource, out *core.StorageOSPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_StorageOSPersistentVolumeSource_To_core_StorageOSPersistentVolumeSource(in, out, s)
}

func autoConvert_core_StorageOSPersistentVolumeSource_To_v1_StorageOSPersistentVolumeSource(in *core.StorageOSPersistentVolumeSource, out *corev1.StorageOSPersistentVolumeSource, s conversion.Scope) error {
        out.VolumeName = in.VolumeName
        out.VolumeNamespace = in.VolumeNamespace
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.SecretRef = (*corev1.ObjectReference)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_core_StorageOSPersistentVolumeSource_To_v1_StorageOSPersistentVolumeSource is an autogenerated conversion function.
func Convert_core_StorageOSPersistentVolumeSource_To_v1_StorageOSPersistentVolumeSource(in *core.StorageOSPersistentVolumeSource, out *corev1.StorageOSPersistentVolumeSource, s conversion.Scope) error {
        return autoConvert_core_StorageOSPersistentVolumeSource_To_v1_StorageOSPersistentVolumeSource(in, out, s)
}

func autoConvert_v1_StorageOSVolumeSource_To_core_StorageOSVolumeSource(in *corev1.StorageOSVolumeSource, out *core.StorageOSVolumeSource, s conversion.Scope) error {
        out.VolumeName = in.VolumeName
        out.VolumeNamespace = in.VolumeNamespace
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.SecretRef = (*core.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_v1_StorageOSVolumeSource_To_core_StorageOSVolumeSource is an autogenerated conversion function.
func Convert_v1_StorageOSVolumeSource_To_core_StorageOSVolumeSource(in *corev1.StorageOSVolumeSource, out *core.StorageOSVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_StorageOSVolumeSource_To_core_StorageOSVolumeSource(in, out, s)
}

func autoConvert_core_StorageOSVolumeSource_To_v1_StorageOSVolumeSource(in *core.StorageOSVolumeSource, out *corev1.StorageOSVolumeSource, s conversion.Scope) error {
        out.VolumeName = in.VolumeName
        out.VolumeNamespace = in.VolumeNamespace
        out.FSType = in.FSType
        out.ReadOnly = in.ReadOnly
        out.SecretRef = (*corev1.LocalObjectReference)(unsafe.Pointer(in.SecretRef))
        return nil
}

// Convert_core_StorageOSVolumeSource_To_v1_StorageOSVolumeSource is an autogenerated conversion function.
func Convert_core_StorageOSVolumeSource_To_v1_StorageOSVolumeSource(in *core.StorageOSVolumeSource, out *corev1.StorageOSVolumeSource, s conversion.Scope) error {
        return autoConvert_core_StorageOSVolumeSource_To_v1_StorageOSVolumeSource(in, out, s)
}

func autoConvert_v1_Sysctl_To_core_Sysctl(in *corev1.Sysctl, out *core.Sysctl, s conversion.Scope) error {
        out.Name = in.Name
        out.Value = in.Value
        return nil
}

// Convert_v1_Sysctl_To_core_Sysctl is an autogenerated conversion function.
func Convert_v1_Sysctl_To_core_Sysctl(in *corev1.Sysctl, out *core.Sysctl, s conversion.Scope) error {
        return autoConvert_v1_Sysctl_To_core_Sysctl(in, out, s)
}

func autoConvert_core_Sysctl_To_v1_Sysctl(in *core.Sysctl, out *corev1.Sysctl, s conversion.Scope) error {
        out.Name = in.Name
        out.Value = in.Value
        return nil
}

// Convert_core_Sysctl_To_v1_Sysctl is an autogenerated conversion function.
func Convert_core_Sysctl_To_v1_Sysctl(in *core.Sysctl, out *corev1.Sysctl, s conversion.Scope) error {
        return autoConvert_core_Sysctl_To_v1_Sysctl(in, out, s)
}

func autoConvert_v1_TCPSocketAction_To_core_TCPSocketAction(in *corev1.TCPSocketAction, out *core.TCPSocketAction, s conversion.Scope) error {
        out.Port = in.Port
        out.Host = in.Host
        return nil
}

// Convert_v1_TCPSocketAction_To_core_TCPSocketAction is an autogenerated conversion function.
func Convert_v1_TCPSocketAction_To_core_TCPSocketAction(in *corev1.TCPSocketAction, out *core.TCPSocketAction, s conversion.Scope) error {
        return autoConvert_v1_TCPSocketAction_To_core_TCPSocketAction(in, out, s)
}

func autoConvert_core_TCPSocketAction_To_v1_TCPSocketAction(in *core.TCPSocketAction, out *corev1.TCPSocketAction, s conversion.Scope) error {
        out.Port = in.Port
        out.Host = in.Host
        return nil
}

// Convert_core_TCPSocketAction_To_v1_TCPSocketAction is an autogenerated conversion function.
func Convert_core_TCPSocketAction_To_v1_TCPSocketAction(in *core.TCPSocketAction, out *corev1.TCPSocketAction, s conversion.Scope) error {
        return autoConvert_core_TCPSocketAction_To_v1_TCPSocketAction(in, out, s)
}

func autoConvert_v1_Taint_To_core_Taint(in *corev1.Taint, out *core.Taint, s conversion.Scope) error {
        out.Key = in.Key
        out.Value = in.Value
        out.Effect = core.TaintEffect(in.Effect)
        out.TimeAdded = (*metav1.Time)(unsafe.Pointer(in.TimeAdded))
        return nil
}

// Convert_v1_Taint_To_core_Taint is an autogenerated conversion function.
func Convert_v1_Taint_To_core_Taint(in *corev1.Taint, out *core.Taint, s conversion.Scope) error {
        return autoConvert_v1_Taint_To_core_Taint(in, out, s)
}

func autoConvert_core_Taint_To_v1_Taint(in *core.Taint, out *corev1.Taint, s conversion.Scope) error {
        out.Key = in.Key
        out.Value = in.Value
        out.Effect = corev1.TaintEffect(in.Effect)
        out.TimeAdded = (*metav1.Time)(unsafe.Pointer(in.TimeAdded))
        return nil
}

// Convert_core_Taint_To_v1_Taint is an autogenerated conversion function.
func Convert_core_Taint_To_v1_Taint(in *core.Taint, out *corev1.Taint, s conversion.Scope) error {
        return autoConvert_core_Taint_To_v1_Taint(in, out, s)
}

func autoConvert_v1_Toleration_To_core_Toleration(in *corev1.Toleration, out *core.Toleration, s conversion.Scope) error {
        out.Key = in.Key
        out.Operator = core.TolerationOperator(in.Operator)
        out.Value = in.Value
        out.Effect = core.TaintEffect(in.Effect)
        out.TolerationSeconds = (*int64)(unsafe.Pointer(in.TolerationSeconds))
        return nil
}

// Convert_v1_Toleration_To_core_Toleration is an autogenerated conversion function.
func Convert_v1_Toleration_To_core_Toleration(in *corev1.Toleration, out *core.Toleration, s conversion.Scope) error {
        return autoConvert_v1_Toleration_To_core_Toleration(in, out, s)
}

func autoConvert_core_Toleration_To_v1_Toleration(in *core.Toleration, out *corev1.Toleration, s conversion.Scope) error {
        out.Key = in.Key
        out.Operator = corev1.TolerationOperator(in.Operator)
        out.Value = in.Value
        out.Effect = corev1.TaintEffect(in.Effect)
        out.TolerationSeconds = (*int64)(unsafe.Pointer(in.TolerationSeconds))
        return nil
}

// Convert_core_Toleration_To_v1_Toleration is an autogenerated conversion function.
func Convert_core_Toleration_To_v1_Toleration(in *core.Toleration, out *corev1.Toleration, s conversion.Scope) error {
        return autoConvert_core_Toleration_To_v1_Toleration(in, out, s)
}

func autoConvert_v1_TopologySelectorLabelRequirement_To_core_TopologySelectorLabelRequirement(in *corev1.TopologySelectorLabelRequirement, out *core.TopologySelectorLabelRequirement, s conversion.Scope) error {
        out.Key = in.Key
        out.Values = *(*[]string)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_v1_TopologySelectorLabelRequirement_To_core_TopologySelectorLabelRequirement is an autogenerated conversion function.
func Convert_v1_TopologySelectorLabelRequirement_To_core_TopologySelectorLabelRequirement(in *corev1.TopologySelectorLabelRequirement, out *core.TopologySelectorLabelRequirement, s conversion.Scope) error {
        return autoConvert_v1_TopologySelectorLabelRequirement_To_core_TopologySelectorLabelRequirement(in, out, s)
}

func autoConvert_core_TopologySelectorLabelRequirement_To_v1_TopologySelectorLabelRequirement(in *core.TopologySelectorLabelRequirement, out *corev1.TopologySelectorLabelRequirement, s conversion.Scope) error {
        out.Key = in.Key
        out.Values = *(*[]string)(unsafe.Pointer(&in.Values))
        return nil
}

// Convert_core_TopologySelectorLabelRequirement_To_v1_TopologySelectorLabelRequirement is an autogenerated conversion function.
func Convert_core_TopologySelectorLabelRequirement_To_v1_TopologySelectorLabelRequirement(in *core.TopologySelectorLabelRequirement, out *corev1.TopologySelectorLabelRequirement, s conversion.Scope) error {
        return autoConvert_core_TopologySelectorLabelRequirement_To_v1_TopologySelectorLabelRequirement(in, out, s)
}

func autoConvert_v1_TopologySelectorTerm_To_core_TopologySelectorTerm(in *corev1.TopologySelectorTerm, out *core.TopologySelectorTerm, s conversion.Scope) error {
        out.MatchLabelExpressions = *(*[]core.TopologySelectorLabelRequirement)(unsafe.Pointer(&in.MatchLabelExpressions))
        return nil
}

// Convert_v1_TopologySelectorTerm_To_core_TopologySelectorTerm is an autogenerated conversion function.
func Convert_v1_TopologySelectorTerm_To_core_TopologySelectorTerm(in *corev1.TopologySelectorTerm, out *core.TopologySelectorTerm, s conversion.Scope) error {
        return autoConvert_v1_TopologySelectorTerm_To_core_TopologySelectorTerm(in, out, s)
}

func autoConvert_core_TopologySelectorTerm_To_v1_TopologySelectorTerm(in *core.TopologySelectorTerm, out *corev1.TopologySelectorTerm, s conversion.Scope) error {
        out.MatchLabelExpressions = *(*[]corev1.TopologySelectorLabelRequirement)(unsafe.Pointer(&in.MatchLabelExpressions))
        return nil
}

// Convert_core_TopologySelectorTerm_To_v1_TopologySelectorTerm is an autogenerated conversion function.
func Convert_core_TopologySelectorTerm_To_v1_TopologySelectorTerm(in *core.TopologySelectorTerm, out *corev1.TopologySelectorTerm, s conversion.Scope) error {
        return autoConvert_core_TopologySelectorTerm_To_v1_TopologySelectorTerm(in, out, s)
}

func autoConvert_v1_TopologySpreadConstraint_To_core_TopologySpreadConstraint(in *corev1.TopologySpreadConstraint, out *core.TopologySpreadConstraint, s conversion.Scope) error {
        out.MaxSkew = in.MaxSkew
        out.TopologyKey = in.TopologyKey
        out.WhenUnsatisfiable = core.UnsatisfiableConstraintAction(in.WhenUnsatisfiable)
        out.LabelSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.LabelSelector))
        out.MinDomains = (*int32)(unsafe.Pointer(in.MinDomains))
        out.NodeAffinityPolicy = (*core.NodeInclusionPolicy)(unsafe.Pointer(in.NodeAffinityPolicy))
        out.NodeTaintsPolicy = (*core.NodeInclusionPolicy)(unsafe.Pointer(in.NodeTaintsPolicy))
        out.MatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MatchLabelKeys))
        return nil
}

// Convert_v1_TopologySpreadConstraint_To_core_TopologySpreadConstraint is an autogenerated conversion function.
func Convert_v1_TopologySpreadConstraint_To_core_TopologySpreadConstraint(in *corev1.TopologySpreadConstraint, out *core.TopologySpreadConstraint, s conversion.Scope) error {
        return autoConvert_v1_TopologySpreadConstraint_To_core_TopologySpreadConstraint(in, out, s)
}

func autoConvert_core_TopologySpreadConstraint_To_v1_TopologySpreadConstraint(in *core.TopologySpreadConstraint, out *corev1.TopologySpreadConstraint, s conversion.Scope) error {
        out.MaxSkew = in.MaxSkew
        out.TopologyKey = in.TopologyKey
        out.WhenUnsatisfiable = corev1.UnsatisfiableConstraintAction(in.WhenUnsatisfiable)
        out.LabelSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.LabelSelector))
        out.MinDomains = (*int32)(unsafe.Pointer(in.MinDomains))
        out.NodeAffinityPolicy = (*corev1.NodeInclusionPolicy)(unsafe.Pointer(in.NodeAffinityPolicy))
        out.NodeTaintsPolicy = (*corev1.NodeInclusionPolicy)(unsafe.Pointer(in.NodeTaintsPolicy))
        out.MatchLabelKeys = *(*[]string)(unsafe.Pointer(&in.MatchLabelKeys))
        return nil
}

// Convert_core_TopologySpreadConstraint_To_v1_TopologySpreadConstraint is an autogenerated conversion function.
func Convert_core_TopologySpreadConstraint_To_v1_TopologySpreadConstraint(in *core.TopologySpreadConstraint, out *corev1.TopologySpreadConstraint, s conversion.Scope) error {
        return autoConvert_core_TopologySpreadConstraint_To_v1_TopologySpreadConstraint(in, out, s)
}

func autoConvert_v1_TypedLocalObjectReference_To_core_TypedLocalObjectReference(in *corev1.TypedLocalObjectReference, out *core.TypedLocalObjectReference, s conversion.Scope) error {
        out.APIGroup = (*string)(unsafe.Pointer(in.APIGroup))
        out.Kind = in.Kind
        out.Name = in.Name
        return nil
}

// Convert_v1_TypedLocalObjectReference_To_core_TypedLocalObjectReference is an autogenerated conversion function.
func Convert_v1_TypedLocalObjectReference_To_core_TypedLocalObjectReference(in *corev1.TypedLocalObjectReference, out *core.TypedLocalObjectReference, s conversion.Scope) error {
        return autoConvert_v1_TypedLocalObjectReference_To_core_TypedLocalObjectReference(in, out, s)
}

func autoConvert_core_TypedLocalObjectReference_To_v1_TypedLocalObjectReference(in *core.TypedLocalObjectReference, out *corev1.TypedLocalObjectReference, s conversion.Scope) error {
        out.APIGroup = (*string)(unsafe.Pointer(in.APIGroup))
        out.Kind = in.Kind
        out.Name = in.Name
        return nil
}

// Convert_core_TypedLocalObjectReference_To_v1_TypedLocalObjectReference is an autogenerated conversion function.
func Convert_core_TypedLocalObjectReference_To_v1_TypedLocalObjectReference(in *core.TypedLocalObjectReference, out *corev1.TypedLocalObjectReference, s conversion.Scope) error {
        return autoConvert_core_TypedLocalObjectReference_To_v1_TypedLocalObjectReference(in, out, s)
}

func autoConvert_v1_TypedObjectReference_To_core_TypedObjectReference(in *corev1.TypedObjectReference, out *core.TypedObjectReference, s conversion.Scope) error {
        out.APIGroup = (*string)(unsafe.Pointer(in.APIGroup))
        out.Kind = in.Kind
        out.Name = in.Name
        out.Namespace = (*string)(unsafe.Pointer(in.Namespace))
        return nil
}

// Convert_v1_TypedObjectReference_To_core_TypedObjectReference is an autogenerated conversion function.
func Convert_v1_TypedObjectReference_To_core_TypedObjectReference(in *corev1.TypedObjectReference, out *core.TypedObjectReference, s conversion.Scope) error {
        return autoConvert_v1_TypedObjectReference_To_core_TypedObjectReference(in, out, s)
}

func autoConvert_core_TypedObjectReference_To_v1_TypedObjectReference(in *core.TypedObjectReference, out *corev1.TypedObjectReference, s conversion.Scope) error {
        out.APIGroup = (*string)(unsafe.Pointer(in.APIGroup))
        out.Kind = in.Kind
        out.Name = in.Name
        out.Namespace = (*string)(unsafe.Pointer(in.Namespace))
        return nil
}

// Convert_core_TypedObjectReference_To_v1_TypedObjectReference is an autogenerated conversion function.
func Convert_core_TypedObjectReference_To_v1_TypedObjectReference(in *core.TypedObjectReference, out *corev1.TypedObjectReference, s conversion.Scope) error {
        return autoConvert_core_TypedObjectReference_To_v1_TypedObjectReference(in, out, s)
}

func autoConvert_v1_Volume_To_core_Volume(in *corev1.Volume, out *core.Volume, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_v1_VolumeSource_To_core_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_Volume_To_core_Volume is an autogenerated conversion function.
func Convert_v1_Volume_To_core_Volume(in *corev1.Volume, out *core.Volume, s conversion.Scope) error {
        return autoConvert_v1_Volume_To_core_Volume(in, out, s)
}

func autoConvert_core_Volume_To_v1_Volume(in *core.Volume, out *corev1.Volume, s conversion.Scope) error {
        out.Name = in.Name
        if err := Convert_core_VolumeSource_To_v1_VolumeSource(&in.VolumeSource, &out.VolumeSource, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_Volume_To_v1_Volume is an autogenerated conversion function.
func Convert_core_Volume_To_v1_Volume(in *core.Volume, out *corev1.Volume, s conversion.Scope) error {
        return autoConvert_core_Volume_To_v1_Volume(in, out, s)
}

func autoConvert_v1_VolumeDevice_To_core_VolumeDevice(in *corev1.VolumeDevice, out *core.VolumeDevice, s conversion.Scope) error {
        out.Name = in.Name
        out.DevicePath = in.DevicePath
        return nil
}

// Convert_v1_VolumeDevice_To_core_VolumeDevice is an autogenerated conversion function.
func Convert_v1_VolumeDevice_To_core_VolumeDevice(in *corev1.VolumeDevice, out *core.VolumeDevice, s conversion.Scope) error {
        return autoConvert_v1_VolumeDevice_To_core_VolumeDevice(in, out, s)
}

func autoConvert_core_VolumeDevice_To_v1_VolumeDevice(in *core.VolumeDevice, out *corev1.VolumeDevice, s conversion.Scope) error {
        out.Name = in.Name
        out.DevicePath = in.DevicePath
        return nil
}

// Convert_core_VolumeDevice_To_v1_VolumeDevice is an autogenerated conversion function.
func Convert_core_VolumeDevice_To_v1_VolumeDevice(in *core.VolumeDevice, out *corev1.VolumeDevice, s conversion.Scope) error {
        return autoConvert_core_VolumeDevice_To_v1_VolumeDevice(in, out, s)
}

func autoConvert_v1_VolumeMount_To_core_VolumeMount(in *corev1.VolumeMount, out *core.VolumeMount, s conversion.Scope) error {
        out.Name = in.Name
        out.ReadOnly = in.ReadOnly
        out.RecursiveReadOnly = (*core.RecursiveReadOnlyMode)(unsafe.Pointer(in.RecursiveReadOnly))
        out.MountPath = in.MountPath
        out.SubPath = in.SubPath
        out.MountPropagation = (*core.MountPropagationMode)(unsafe.Pointer(in.MountPropagation))
        out.SubPathExpr = in.SubPathExpr
        return nil
}

// Convert_v1_VolumeMount_To_core_VolumeMount is an autogenerated conversion function.
func Convert_v1_VolumeMount_To_core_VolumeMount(in *corev1.VolumeMount, out *core.VolumeMount, s conversion.Scope) error {
        return autoConvert_v1_VolumeMount_To_core_VolumeMount(in, out, s)
}

func autoConvert_core_VolumeMount_To_v1_VolumeMount(in *core.VolumeMount, out *corev1.VolumeMount, s conversion.Scope) error {
        out.Name = in.Name
        out.ReadOnly = in.ReadOnly
        out.RecursiveReadOnly = (*corev1.RecursiveReadOnlyMode)(unsafe.Pointer(in.RecursiveReadOnly))
        out.MountPath = in.MountPath
        out.SubPath = in.SubPath
        out.MountPropagation = (*corev1.MountPropagationMode)(unsafe.Pointer(in.MountPropagation))
        out.SubPathExpr = in.SubPathExpr
        return nil
}

// Convert_core_VolumeMount_To_v1_VolumeMount is an autogenerated conversion function.
func Convert_core_VolumeMount_To_v1_VolumeMount(in *core.VolumeMount, out *corev1.VolumeMount, s conversion.Scope) error {
        return autoConvert_core_VolumeMount_To_v1_VolumeMount(in, out, s)
}

func autoConvert_v1_VolumeMountStatus_To_core_VolumeMountStatus(in *corev1.VolumeMountStatus, out *core.VolumeMountStatus, s conversion.Scope) error {
        out.Name = in.Name
        out.MountPath = in.MountPath
        out.ReadOnly = in.ReadOnly
        out.RecursiveReadOnly = (*core.RecursiveReadOnlyMode)(unsafe.Pointer(in.RecursiveReadOnly))
        return nil
}

// Convert_v1_VolumeMountStatus_To_core_VolumeMountStatus is an autogenerated conversion function.
func Convert_v1_VolumeMountStatus_To_core_VolumeMountStatus(in *corev1.VolumeMountStatus, out *core.VolumeMountStatus, s conversion.Scope) error {
        return autoConvert_v1_VolumeMountStatus_To_core_VolumeMountStatus(in, out, s)
}

func autoConvert_core_VolumeMountStatus_To_v1_VolumeMountStatus(in *core.VolumeMountStatus, out *corev1.VolumeMountStatus, s conversion.Scope) error {
        out.Name = in.Name
        out.MountPath = in.MountPath
        out.ReadOnly = in.ReadOnly
        out.RecursiveReadOnly = (*corev1.RecursiveReadOnlyMode)(unsafe.Pointer(in.RecursiveReadOnly))
        return nil
}

// Convert_core_VolumeMountStatus_To_v1_VolumeMountStatus is an autogenerated conversion function.
func Convert_core_VolumeMountStatus_To_v1_VolumeMountStatus(in *core.VolumeMountStatus, out *corev1.VolumeMountStatus, s conversion.Scope) error {
        return autoConvert_core_VolumeMountStatus_To_v1_VolumeMountStatus(in, out, s)
}

func autoConvert_v1_VolumeNodeAffinity_To_core_VolumeNodeAffinity(in *corev1.VolumeNodeAffinity, out *core.VolumeNodeAffinity, s conversion.Scope) error {
        out.Required = (*core.NodeSelector)(unsafe.Pointer(in.Required))
        return nil
}

// Convert_v1_VolumeNodeAffinity_To_core_VolumeNodeAffinity is an autogenerated conversion function.
func Convert_v1_VolumeNodeAffinity_To_core_VolumeNodeAffinity(in *corev1.VolumeNodeAffinity, out *core.VolumeNodeAffinity, s conversion.Scope) error {
        return autoConvert_v1_VolumeNodeAffinity_To_core_VolumeNodeAffinity(in, out, s)
}

func autoConvert_core_VolumeNodeAffinity_To_v1_VolumeNodeAffinity(in *core.VolumeNodeAffinity, out *corev1.VolumeNodeAffinity, s conversion.Scope) error {
        out.Required = (*corev1.NodeSelector)(unsafe.Pointer(in.Required))
        return nil
}

// Convert_core_VolumeNodeAffinity_To_v1_VolumeNodeAffinity is an autogenerated conversion function.
func Convert_core_VolumeNodeAffinity_To_v1_VolumeNodeAffinity(in *core.VolumeNodeAffinity, out *corev1.VolumeNodeAffinity, s conversion.Scope) error {
        return autoConvert_core_VolumeNodeAffinity_To_v1_VolumeNodeAffinity(in, out, s)
}

func autoConvert_v1_VolumeProjection_To_core_VolumeProjection(in *corev1.VolumeProjection, out *core.VolumeProjection, s conversion.Scope) error {
        out.Secret = (*core.SecretProjection)(unsafe.Pointer(in.Secret))
        out.DownwardAPI = (*core.DownwardAPIProjection)(unsafe.Pointer(in.DownwardAPI))
        out.ConfigMap = (*core.ConfigMapProjection)(unsafe.Pointer(in.ConfigMap))
        if in.ServiceAccountToken != nil {
                in, out := &in.ServiceAccountToken, &out.ServiceAccountToken
                *out = new(core.ServiceAccountTokenProjection)
                if err := Convert_v1_ServiceAccountTokenProjection_To_core_ServiceAccountTokenProjection(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ServiceAccountToken = nil
        }
        out.ClusterTrustBundle = (*core.ClusterTrustBundleProjection)(unsafe.Pointer(in.ClusterTrustBundle))
        out.PodCertificate = (*core.PodCertificateProjection)(unsafe.Pointer(in.PodCertificate))
        return nil
}

// Convert_v1_VolumeProjection_To_core_VolumeProjection is an autogenerated conversion function.
func Convert_v1_VolumeProjection_To_core_VolumeProjection(in *corev1.VolumeProjection, out *core.VolumeProjection, s conversion.Scope) error {
        return autoConvert_v1_VolumeProjection_To_core_VolumeProjection(in, out, s)
}

func autoConvert_core_VolumeProjection_To_v1_VolumeProjection(in *core.VolumeProjection, out *corev1.VolumeProjection, s conversion.Scope) error {
        out.Secret = (*corev1.SecretProjection)(unsafe.Pointer(in.Secret))
        out.DownwardAPI = (*corev1.DownwardAPIProjection)(unsafe.Pointer(in.DownwardAPI))
        out.ConfigMap = (*corev1.ConfigMapProjection)(unsafe.Pointer(in.ConfigMap))
        if in.ServiceAccountToken != nil {
                in, out := &in.ServiceAccountToken, &out.ServiceAccountToken
                *out = new(corev1.ServiceAccountTokenProjection)
                if err := Convert_core_ServiceAccountTokenProjection_To_v1_ServiceAccountTokenProjection(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.ServiceAccountToken = nil
        }
        out.ClusterTrustBundle = (*corev1.ClusterTrustBundleProjection)(unsafe.Pointer(in.ClusterTrustBundle))
        out.PodCertificate = (*corev1.PodCertificateProjection)(unsafe.Pointer(in.PodCertificate))
        return nil
}

// Convert_core_VolumeProjection_To_v1_VolumeProjection is an autogenerated conversion function.
func Convert_core_VolumeProjection_To_v1_VolumeProjection(in *core.VolumeProjection, out *corev1.VolumeProjection, s conversion.Scope) error {
        return autoConvert_core_VolumeProjection_To_v1_VolumeProjection(in, out, s)
}

func autoConvert_v1_VolumeResourceRequirements_To_core_VolumeResourceRequirements(in *corev1.VolumeResourceRequirements, out *core.VolumeResourceRequirements, s conversion.Scope) error {
        out.Limits = *(*core.ResourceList)(unsafe.Pointer(&in.Limits))
        out.Requests = *(*core.ResourceList)(unsafe.Pointer(&in.Requests))
        return nil
}

// Convert_v1_VolumeResourceRequirements_To_core_VolumeResourceRequirements is an autogenerated conversion function.
func Convert_v1_VolumeResourceRequirements_To_core_VolumeResourceRequirements(in *corev1.VolumeResourceRequirements, out *core.VolumeResourceRequirements, s conversion.Scope) error {
        return autoConvert_v1_VolumeResourceRequirements_To_core_VolumeResourceRequirements(in, out, s)
}

func autoConvert_core_VolumeResourceRequirements_To_v1_VolumeResourceRequirements(in *core.VolumeResourceRequirements, out *corev1.VolumeResourceRequirements, s conversion.Scope) error {
        out.Limits = *(*corev1.ResourceList)(unsafe.Pointer(&in.Limits))
        out.Requests = *(*corev1.ResourceList)(unsafe.Pointer(&in.Requests))
        return nil
}

// Convert_core_VolumeResourceRequirements_To_v1_VolumeResourceRequirements is an autogenerated conversion function.
func Convert_core_VolumeResourceRequirements_To_v1_VolumeResourceRequirements(in *core.VolumeResourceRequirements, out *corev1.VolumeResourceRequirements, s conversion.Scope) error {
        return autoConvert_core_VolumeResourceRequirements_To_v1_VolumeResourceRequirements(in, out, s)
}

func autoConvert_v1_VolumeSource_To_core_VolumeSource(in *corev1.VolumeSource, out *core.VolumeSource, s conversion.Scope) error {
        out.HostPath = (*core.HostPathVolumeSource)(unsafe.Pointer(in.HostPath))
        out.EmptyDir = (*core.EmptyDirVolumeSource)(unsafe.Pointer(in.EmptyDir))
        out.GCEPersistentDisk = (*core.GCEPersistentDiskVolumeSource)(unsafe.Pointer(in.GCEPersistentDisk))
        out.AWSElasticBlockStore = (*core.AWSElasticBlockStoreVolumeSource)(unsafe.Pointer(in.AWSElasticBlockStore))
        out.GitRepo = (*core.GitRepoVolumeSource)(unsafe.Pointer(in.GitRepo))
        out.Secret = (*core.SecretVolumeSource)(unsafe.Pointer(in.Secret))
        out.NFS = (*core.NFSVolumeSource)(unsafe.Pointer(in.NFS))
        out.ISCSI = (*core.ISCSIVolumeSource)(unsafe.Pointer(in.ISCSI))
        out.Glusterfs = (*core.GlusterfsVolumeSource)(unsafe.Pointer(in.Glusterfs))
        out.PersistentVolumeClaim = (*core.PersistentVolumeClaimVolumeSource)(unsafe.Pointer(in.PersistentVolumeClaim))
        out.RBD = (*core.RBDVolumeSource)(unsafe.Pointer(in.RBD))
        out.FlexVolume = (*core.FlexVolumeSource)(unsafe.Pointer(in.FlexVolume))
        out.Cinder = (*core.CinderVolumeSource)(unsafe.Pointer(in.Cinder))
        out.CephFS = (*core.CephFSVolumeSource)(unsafe.Pointer(in.CephFS))
        out.Flocker = (*core.FlockerVolumeSource)(unsafe.Pointer(in.Flocker))
        out.DownwardAPI = (*core.DownwardAPIVolumeSource)(unsafe.Pointer(in.DownwardAPI))
        out.FC = (*core.FCVolumeSource)(unsafe.Pointer(in.FC))
        out.AzureFile = (*core.AzureFileVolumeSource)(unsafe.Pointer(in.AzureFile))
        out.ConfigMap = (*core.ConfigMapVolumeSource)(unsafe.Pointer(in.ConfigMap))
        out.VsphereVolume = (*core.VsphereVirtualDiskVolumeSource)(unsafe.Pointer(in.VsphereVolume))
        out.Quobyte = (*core.QuobyteVolumeSource)(unsafe.Pointer(in.Quobyte))
        out.AzureDisk = (*core.AzureDiskVolumeSource)(unsafe.Pointer(in.AzureDisk))
        out.PhotonPersistentDisk = (*core.PhotonPersistentDiskVolumeSource)(unsafe.Pointer(in.PhotonPersistentDisk))
        if in.Projected != nil {
                in, out := &in.Projected, &out.Projected
                *out = new(core.ProjectedVolumeSource)
                if err := Convert_v1_ProjectedVolumeSource_To_core_ProjectedVolumeSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Projected = nil
        }
        out.PortworxVolume = (*core.PortworxVolumeSource)(unsafe.Pointer(in.PortworxVolume))
        out.ScaleIO = (*core.ScaleIOVolumeSource)(unsafe.Pointer(in.ScaleIO))
        out.StorageOS = (*core.StorageOSVolumeSource)(unsafe.Pointer(in.StorageOS))
        out.CSI = (*core.CSIVolumeSource)(unsafe.Pointer(in.CSI))
        out.Ephemeral = (*core.EphemeralVolumeSource)(unsafe.Pointer(in.Ephemeral))
        out.Image = (*core.ImageVolumeSource)(unsafe.Pointer(in.Image))
        return nil
}

// Convert_v1_VolumeSource_To_core_VolumeSource is an autogenerated conversion function.
func Convert_v1_VolumeSource_To_core_VolumeSource(in *corev1.VolumeSource, out *core.VolumeSource, s conversion.Scope) error {
        return autoConvert_v1_VolumeSource_To_core_VolumeSource(in, out, s)
}

func autoConvert_core_VolumeSource_To_v1_VolumeSource(in *core.VolumeSource, out *corev1.VolumeSource, s conversion.Scope) error {
        out.HostPath = (*corev1.HostPathVolumeSource)(unsafe.Pointer(in.HostPath))
        out.EmptyDir = (*corev1.EmptyDirVolumeSource)(unsafe.Pointer(in.EmptyDir))
        out.GCEPersistentDisk = (*corev1.GCEPersistentDiskVolumeSource)(unsafe.Pointer(in.GCEPersistentDisk))
        out.AWSElasticBlockStore = (*corev1.AWSElasticBlockStoreVolumeSource)(unsafe.Pointer(in.AWSElasticBlockStore))
        out.GitRepo = (*corev1.GitRepoVolumeSource)(unsafe.Pointer(in.GitRepo))
        out.Secret = (*corev1.SecretVolumeSource)(unsafe.Pointer(in.Secret))
        out.NFS = (*corev1.NFSVolumeSource)(unsafe.Pointer(in.NFS))
        out.ISCSI = (*corev1.ISCSIVolumeSource)(unsafe.Pointer(in.ISCSI))
        out.Glusterfs = (*corev1.GlusterfsVolumeSource)(unsafe.Pointer(in.Glusterfs))
        out.PersistentVolumeClaim = (*corev1.PersistentVolumeClaimVolumeSource)(unsafe.Pointer(in.PersistentVolumeClaim))
        out.RBD = (*corev1.RBDVolumeSource)(unsafe.Pointer(in.RBD))
        out.Quobyte = (*corev1.QuobyteVolumeSource)(unsafe.Pointer(in.Quobyte))
        out.FlexVolume = (*corev1.FlexVolumeSource)(unsafe.Pointer(in.FlexVolume))
        out.Cinder = (*corev1.CinderVolumeSource)(unsafe.Pointer(in.Cinder))
        out.CephFS = (*corev1.CephFSVolumeSource)(unsafe.Pointer(in.CephFS))
        out.Flocker = (*corev1.FlockerVolumeSource)(unsafe.Pointer(in.Flocker))
        out.DownwardAPI = (*corev1.DownwardAPIVolumeSource)(unsafe.Pointer(in.DownwardAPI))
        out.FC = (*corev1.FCVolumeSource)(unsafe.Pointer(in.FC))
        out.AzureFile = (*corev1.AzureFileVolumeSource)(unsafe.Pointer(in.AzureFile))
        out.ConfigMap = (*corev1.ConfigMapVolumeSource)(unsafe.Pointer(in.ConfigMap))
        out.VsphereVolume = (*corev1.VsphereVirtualDiskVolumeSource)(unsafe.Pointer(in.VsphereVolume))
        out.AzureDisk = (*corev1.AzureDiskVolumeSource)(unsafe.Pointer(in.AzureDisk))
        out.PhotonPersistentDisk = (*corev1.PhotonPersistentDiskVolumeSource)(unsafe.Pointer(in.PhotonPersistentDisk))
        if in.Projected != nil {
                in, out := &in.Projected, &out.Projected
                *out = new(corev1.ProjectedVolumeSource)
                if err := Convert_core_ProjectedVolumeSource_To_v1_ProjectedVolumeSource(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.Projected = nil
        }
        out.PortworxVolume = (*corev1.PortworxVolumeSource)(unsafe.Pointer(in.PortworxVolume))
        out.ScaleIO = (*corev1.ScaleIOVolumeSource)(unsafe.Pointer(in.ScaleIO))
        out.StorageOS = (*corev1.StorageOSVolumeSource)(unsafe.Pointer(in.StorageOS))
        out.CSI = (*corev1.CSIVolumeSource)(unsafe.Pointer(in.CSI))
        out.Ephemeral = (*corev1.EphemeralVolumeSource)(unsafe.Pointer(in.Ephemeral))
        out.Image = (*corev1.ImageVolumeSource)(unsafe.Pointer(in.Image))
        return nil
}

// Convert_core_VolumeSource_To_v1_VolumeSource is an autogenerated conversion function.
func Convert_core_VolumeSource_To_v1_VolumeSource(in *core.VolumeSource, out *corev1.VolumeSource, s conversion.Scope) error {
        return autoConvert_core_VolumeSource_To_v1_VolumeSource(in, out, s)
}

func autoConvert_v1_VsphereVirtualDiskVolumeSource_To_core_VsphereVirtualDiskVolumeSource(in *corev1.VsphereVirtualDiskVolumeSource, out *core.VsphereVirtualDiskVolumeSource, s conversion.Scope) error {
        out.VolumePath = in.VolumePath
        out.FSType = in.FSType
        out.StoragePolicyName = in.StoragePolicyName
        out.StoragePolicyID = in.StoragePolicyID
        return nil
}

// Convert_v1_VsphereVirtualDiskVolumeSource_To_core_VsphereVirtualDiskVolumeSource is an autogenerated conversion function.
func Convert_v1_VsphereVirtualDiskVolumeSource_To_core_VsphereVirtualDiskVolumeSource(in *corev1.VsphereVirtualDiskVolumeSource, out *core.VsphereVirtualDiskVolumeSource, s conversion.Scope) error {
        return autoConvert_v1_VsphereVirtualDiskVolumeSource_To_core_VsphereVirtualDiskVolumeSource(in, out, s)
}

func autoConvert_core_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(in *core.VsphereVirtualDiskVolumeSource, out *corev1.VsphereVirtualDiskVolumeSource, s conversion.Scope) error {
        out.VolumePath = in.VolumePath
        out.FSType = in.FSType
        out.StoragePolicyName = in.StoragePolicyName
        out.StoragePolicyID = in.StoragePolicyID
        return nil
}

// Convert_core_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource is an autogenerated conversion function.
func Convert_core_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(in *core.VsphereVirtualDiskVolumeSource, out *corev1.VsphereVirtualDiskVolumeSource, s conversion.Scope) error {
        return autoConvert_core_VsphereVirtualDiskVolumeSource_To_v1_VsphereVirtualDiskVolumeSource(in, out, s)
}

func autoConvert_v1_WeightedPodAffinityTerm_To_core_WeightedPodAffinityTerm(in *corev1.WeightedPodAffinityTerm, out *core.WeightedPodAffinityTerm, s conversion.Scope) error {
        out.Weight = in.Weight
        if err := Convert_v1_PodAffinityTerm_To_core_PodAffinityTerm(&in.PodAffinityTerm, &out.PodAffinityTerm, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_WeightedPodAffinityTerm_To_core_WeightedPodAffinityTerm is an autogenerated conversion function.
func Convert_v1_WeightedPodAffinityTerm_To_core_WeightedPodAffinityTerm(in *corev1.WeightedPodAffinityTerm, out *core.WeightedPodAffinityTerm, s conversion.Scope) error {
        return autoConvert_v1_WeightedPodAffinityTerm_To_core_WeightedPodAffinityTerm(in, out, s)
}

func autoConvert_core_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(in *core.WeightedPodAffinityTerm, out *corev1.WeightedPodAffinityTerm, s conversion.Scope) error {
        out.Weight = in.Weight
        if err := Convert_core_PodAffinityTerm_To_v1_PodAffinityTerm(&in.PodAffinityTerm, &out.PodAffinityTerm, s); err != nil {
                return err
        }
        return nil
}

// Convert_core_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm is an autogenerated conversion function.
func Convert_core_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(in *core.WeightedPodAffinityTerm, out *corev1.WeightedPodAffinityTerm, s conversion.Scope) error {
        return autoConvert_core_WeightedPodAffinityTerm_To_v1_WeightedPodAffinityTerm(in, out, s)
}

func autoConvert_v1_WindowsSecurityContextOptions_To_core_WindowsSecurityContextOptions(in *corev1.WindowsSecurityContextOptions, out *core.WindowsSecurityContextOptions, s conversion.Scope) error {
        out.GMSACredentialSpecName = (*string)(unsafe.Pointer(in.GMSACredentialSpecName))
        out.GMSACredentialSpec = (*string)(unsafe.Pointer(in.GMSACredentialSpec))
        out.RunAsUserName = (*string)(unsafe.Pointer(in.RunAsUserName))
        out.HostProcess = (*bool)(unsafe.Pointer(in.HostProcess))
        return nil
}

// Convert_v1_WindowsSecurityContextOptions_To_core_WindowsSecurityContextOptions is an autogenerated conversion function.
func Convert_v1_WindowsSecurityContextOptions_To_core_WindowsSecurityContextOptions(in *corev1.WindowsSecurityContextOptions, out *core.WindowsSecurityContextOptions, s conversion.Scope) error {
        return autoConvert_v1_WindowsSecurityContextOptions_To_core_WindowsSecurityContextOptions(in, out, s)
}

func autoConvert_core_WindowsSecurityContextOptions_To_v1_WindowsSecurityContextOptions(in *core.WindowsSecurityContextOptions, out *corev1.WindowsSecurityContextOptions, s conversion.Scope) error {
        out.GMSACredentialSpecName = (*string)(unsafe.Pointer(in.GMSACredentialSpecName))
        out.GMSACredentialSpec = (*string)(unsafe.Pointer(in.GMSACredentialSpec))
        out.RunAsUserName = (*string)(unsafe.Pointer(in.RunAsUserName))
        out.HostProcess = (*bool)(unsafe.Pointer(in.HostProcess))
        return nil
}

// Convert_core_WindowsSecurityContextOptions_To_v1_WindowsSecurityContextOptions is an autogenerated conversion function.
func Convert_core_WindowsSecurityContextOptions_To_v1_WindowsSecurityContextOptions(in *core.WindowsSecurityContextOptions, out *corev1.WindowsSecurityContextOptions, s conversion.Scope) error {
        return autoConvert_core_WindowsSecurityContextOptions_To_v1_WindowsSecurityContextOptions(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        corev1 "k8s.io/api/core/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&corev1.ConfigMap{}, func(obj interface{}) { SetObjectDefaults_ConfigMap(obj.(*corev1.ConfigMap)) })
        scheme.AddTypeDefaultingFunc(&corev1.ConfigMapList{}, func(obj interface{}) { SetObjectDefaults_ConfigMapList(obj.(*corev1.ConfigMapList)) })
        scheme.AddTypeDefaultingFunc(&corev1.Endpoints{}, func(obj interface{}) { SetObjectDefaults_Endpoints(obj.(*corev1.Endpoints)) })
        scheme.AddTypeDefaultingFunc(&corev1.EndpointsList{}, func(obj interface{}) { SetObjectDefaults_EndpointsList(obj.(*corev1.EndpointsList)) })
        scheme.AddTypeDefaultingFunc(&corev1.LimitRange{}, func(obj interface{}) { SetObjectDefaults_LimitRange(obj.(*corev1.LimitRange)) })
        scheme.AddTypeDefaultingFunc(&corev1.LimitRangeList{}, func(obj interface{}) { SetObjectDefaults_LimitRangeList(obj.(*corev1.LimitRangeList)) })
        scheme.AddTypeDefaultingFunc(&corev1.Namespace{}, func(obj interface{}) { SetObjectDefaults_Namespace(obj.(*corev1.Namespace)) })
        scheme.AddTypeDefaultingFunc(&corev1.NamespaceList{}, func(obj interface{}) { SetObjectDefaults_NamespaceList(obj.(*corev1.NamespaceList)) })
        scheme.AddTypeDefaultingFunc(&corev1.Node{}, func(obj interface{}) { SetObjectDefaults_Node(obj.(*corev1.Node)) })
        scheme.AddTypeDefaultingFunc(&corev1.NodeList{}, func(obj interface{}) { SetObjectDefaults_NodeList(obj.(*corev1.NodeList)) })
        scheme.AddTypeDefaultingFunc(&corev1.PersistentVolume{}, func(obj interface{}) { SetObjectDefaults_PersistentVolume(obj.(*corev1.PersistentVolume)) })
        scheme.AddTypeDefaultingFunc(&corev1.PersistentVolumeClaim{}, func(obj interface{}) { SetObjectDefaults_PersistentVolumeClaim(obj.(*corev1.PersistentVolumeClaim)) })
        scheme.AddTypeDefaultingFunc(&corev1.PersistentVolumeClaimList{}, func(obj interface{}) {
                SetObjectDefaults_PersistentVolumeClaimList(obj.(*corev1.PersistentVolumeClaimList))
        })
        scheme.AddTypeDefaultingFunc(&corev1.PersistentVolumeList{}, func(obj interface{}) { SetObjectDefaults_PersistentVolumeList(obj.(*corev1.PersistentVolumeList)) })
        scheme.AddTypeDefaultingFunc(&corev1.Pod{}, func(obj interface{}) { SetObjectDefaults_Pod(obj.(*corev1.Pod)) })
        scheme.AddTypeDefaultingFunc(&corev1.PodList{}, func(obj interface{}) { SetObjectDefaults_PodList(obj.(*corev1.PodList)) })
        scheme.AddTypeDefaultingFunc(&corev1.PodLogOptions{}, func(obj interface{}) { SetObjectDefaults_PodLogOptions(obj.(*corev1.PodLogOptions)) })
        scheme.AddTypeDefaultingFunc(&corev1.PodStatusResult{}, func(obj interface{}) { SetObjectDefaults_PodStatusResult(obj.(*corev1.PodStatusResult)) })
        scheme.AddTypeDefaultingFunc(&corev1.PodTemplate{}, func(obj interface{}) { SetObjectDefaults_PodTemplate(obj.(*corev1.PodTemplate)) })
        scheme.AddTypeDefaultingFunc(&corev1.PodTemplateList{}, func(obj interface{}) { SetObjectDefaults_PodTemplateList(obj.(*corev1.PodTemplateList)) })
        scheme.AddTypeDefaultingFunc(&corev1.ReplicationController{}, func(obj interface{}) { SetObjectDefaults_ReplicationController(obj.(*corev1.ReplicationController)) })
        scheme.AddTypeDefaultingFunc(&corev1.ReplicationControllerList{}, func(obj interface{}) {
                SetObjectDefaults_ReplicationControllerList(obj.(*corev1.ReplicationControllerList))
        })
        scheme.AddTypeDefaultingFunc(&corev1.ResourceQuota{}, func(obj interface{}) { SetObjectDefaults_ResourceQuota(obj.(*corev1.ResourceQuota)) })
        scheme.AddTypeDefaultingFunc(&corev1.ResourceQuotaList{}, func(obj interface{}) { SetObjectDefaults_ResourceQuotaList(obj.(*corev1.ResourceQuotaList)) })
        scheme.AddTypeDefaultingFunc(&corev1.Secret{}, func(obj interface{}) { SetObjectDefaults_Secret(obj.(*corev1.Secret)) })
        scheme.AddTypeDefaultingFunc(&corev1.SecretList{}, func(obj interface{}) { SetObjectDefaults_SecretList(obj.(*corev1.SecretList)) })
        scheme.AddTypeDefaultingFunc(&corev1.Service{}, func(obj interface{}) { SetObjectDefaults_Service(obj.(*corev1.Service)) })
        scheme.AddTypeDefaultingFunc(&corev1.ServiceList{}, func(obj interface{}) { SetObjectDefaults_ServiceList(obj.(*corev1.ServiceList)) })
        return nil
}

func SetObjectDefaults_ConfigMap(in *corev1.ConfigMap) {
        SetDefaults_ConfigMap(in)
}

func SetObjectDefaults_ConfigMapList(in *corev1.ConfigMapList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ConfigMap(a)
        }
}

func SetObjectDefaults_Endpoints(in *corev1.Endpoints) {
        SetDefaults_Endpoints(in)
}

func SetObjectDefaults_EndpointsList(in *corev1.EndpointsList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Endpoints(a)
        }
}

func SetObjectDefaults_LimitRange(in *corev1.LimitRange) {
        for i := range in.Spec.Limits {
                a := &in.Spec.Limits[i]
                SetDefaults_LimitRangeItem(a)
                SetDefaults_ResourceList(&a.Max)
                SetDefaults_ResourceList(&a.Min)
                SetDefaults_ResourceList(&a.Default)
                SetDefaults_ResourceList(&a.DefaultRequest)
                SetDefaults_ResourceList(&a.MaxLimitRequestRatio)
        }
}

func SetObjectDefaults_LimitRangeList(in *corev1.LimitRangeList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_LimitRange(a)
        }
}

func SetObjectDefaults_Namespace(in *corev1.Namespace) {
        SetDefaults_Namespace(in)
        SetDefaults_NamespaceStatus(&in.Status)
}

func SetObjectDefaults_NamespaceList(in *corev1.NamespaceList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Namespace(a)
        }
}

func SetObjectDefaults_Node(in *corev1.Node) {
        SetDefaults_NodeStatus(&in.Status)
        SetDefaults_ResourceList(&in.Status.Capacity)
        SetDefaults_ResourceList(&in.Status.Allocatable)
}

func SetObjectDefaults_NodeList(in *corev1.NodeList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Node(a)
        }
}

func SetObjectDefaults_PersistentVolume(in *corev1.PersistentVolume) {
        SetDefaults_PersistentVolume(in)
        SetDefaults_ResourceList(&in.Spec.Capacity)
        if in.Spec.PersistentVolumeSource.HostPath != nil {
                SetDefaults_HostPathVolumeSource(in.Spec.PersistentVolumeSource.HostPath)
        }
        if in.Spec.PersistentVolumeSource.RBD != nil {
                if in.Spec.PersistentVolumeSource.RBD.RBDPool == "" {
                        in.Spec.PersistentVolumeSource.RBD.RBDPool = "rbd"
                }
                if in.Spec.PersistentVolumeSource.RBD.RadosUser == "" {
                        in.Spec.PersistentVolumeSource.RBD.RadosUser = "admin"
                }
                if in.Spec.PersistentVolumeSource.RBD.Keyring == "" {
                        in.Spec.PersistentVolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                }
        }
        if in.Spec.PersistentVolumeSource.ISCSI != nil {
                if in.Spec.PersistentVolumeSource.ISCSI.ISCSIInterface == "" {
                        in.Spec.PersistentVolumeSource.ISCSI.ISCSIInterface = "default"
                }
        }
        if in.Spec.PersistentVolumeSource.AzureDisk != nil {
                if in.Spec.PersistentVolumeSource.AzureDisk.CachingMode == nil {
                        ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                        in.Spec.PersistentVolumeSource.AzureDisk.CachingMode = &ptrVar1
                }
                if in.Spec.PersistentVolumeSource.AzureDisk.FSType == nil {
                        var ptrVar1 string = "ext4"
                        in.Spec.PersistentVolumeSource.AzureDisk.FSType = &ptrVar1
                }
                if in.Spec.PersistentVolumeSource.AzureDisk.ReadOnly == nil {
                        var ptrVar1 bool = false
                        in.Spec.PersistentVolumeSource.AzureDisk.ReadOnly = &ptrVar1
                }
                if in.Spec.PersistentVolumeSource.AzureDisk.Kind == nil {
                        ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                        in.Spec.PersistentVolumeSource.AzureDisk.Kind = &ptrVar1
                }
        }
        if in.Spec.PersistentVolumeSource.ScaleIO != nil {
                if in.Spec.PersistentVolumeSource.ScaleIO.StorageMode == "" {
                        in.Spec.PersistentVolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                }
                if in.Spec.PersistentVolumeSource.ScaleIO.FSType == "" {
                        in.Spec.PersistentVolumeSource.ScaleIO.FSType = "xfs"
                }
        }
}

func SetObjectDefaults_PersistentVolumeClaim(in *corev1.PersistentVolumeClaim) {
        SetDefaults_PersistentVolumeClaim(in)
        SetDefaults_PersistentVolumeClaimSpec(&in.Spec)
        SetDefaults_ResourceList(&in.Spec.Resources.Limits)
        SetDefaults_ResourceList(&in.Spec.Resources.Requests)
        SetDefaults_ResourceList(&in.Status.Capacity)
        SetDefaults_ResourceList(&in.Status.AllocatedResources)
}

func SetObjectDefaults_PersistentVolumeClaimList(in *corev1.PersistentVolumeClaimList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_PersistentVolumeClaim(a)
        }
}

func SetObjectDefaults_PersistentVolumeList(in *corev1.PersistentVolumeList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_PersistentVolume(a)
        }
}

func SetObjectDefaults_Pod(in *corev1.Pod) {
        SetDefaults_Pod(in)
        SetDefaults_PodSpec(&in.Spec)
        for i := range in.Spec.Volumes {
                a := &in.Spec.Volumes[i]
                SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.InitContainers {
                a := &in.Spec.InitContainers[i]
                SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                SetDefaults_ResourceList(&a.Resources.Limits)
                SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Containers {
                a := &in.Spec.Containers[i]
                SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                SetDefaults_ResourceList(&a.Resources.Limits)
                SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.EphemeralContainers {
                a := &in.Spec.EphemeralContainers[i]
                SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        SetDefaults_ResourceList(&in.Spec.Overhead)
        if in.Spec.Resources != nil {
                SetDefaults_ResourceList(&in.Spec.Resources.Limits)
                SetDefaults_ResourceList(&in.Spec.Resources.Requests)
        }
        for i := range in.Status.InitContainerStatuses {
                a := &in.Status.InitContainerStatuses[i]
                SetDefaults_ResourceList(&a.AllocatedResources)
                if a.Resources != nil {
                        SetDefaults_ResourceList(&a.Resources.Limits)
                        SetDefaults_ResourceList(&a.Resources.Requests)
                }
        }
        for i := range in.Status.ContainerStatuses {
                a := &in.Status.ContainerStatuses[i]
                SetDefaults_ResourceList(&a.AllocatedResources)
                if a.Resources != nil {
                        SetDefaults_ResourceList(&a.Resources.Limits)
                        SetDefaults_ResourceList(&a.Resources.Requests)
                }
        }
        for i := range in.Status.EphemeralContainerStatuses {
                a := &in.Status.EphemeralContainerStatuses[i]
                SetDefaults_ResourceList(&a.AllocatedResources)
                if a.Resources != nil {
                        SetDefaults_ResourceList(&a.Resources.Limits)
                        SetDefaults_ResourceList(&a.Resources.Requests)
                }
        }
}

func SetObjectDefaults_PodList(in *corev1.PodList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Pod(a)
        }
}

func SetObjectDefaults_PodLogOptions(in *corev1.PodLogOptions) {
        SetDefaults_PodLogOptions(in)
}

func SetObjectDefaults_PodStatusResult(in *corev1.PodStatusResult) {
        for i := range in.Status.InitContainerStatuses {
                a := &in.Status.InitContainerStatuses[i]
                SetDefaults_ResourceList(&a.AllocatedResources)
                if a.Resources != nil {
                        SetDefaults_ResourceList(&a.Resources.Limits)
                        SetDefaults_ResourceList(&a.Resources.Requests)
                }
        }
        for i := range in.Status.ContainerStatuses {
                a := &in.Status.ContainerStatuses[i]
                SetDefaults_ResourceList(&a.AllocatedResources)
                if a.Resources != nil {
                        SetDefaults_ResourceList(&a.Resources.Limits)
                        SetDefaults_ResourceList(&a.Resources.Requests)
                }
        }
        for i := range in.Status.EphemeralContainerStatuses {
                a := &in.Status.EphemeralContainerStatuses[i]
                SetDefaults_ResourceList(&a.AllocatedResources)
                if a.Resources != nil {
                        SetDefaults_ResourceList(&a.Resources.Limits)
                        SetDefaults_ResourceList(&a.Resources.Requests)
                }
        }
}

func SetObjectDefaults_PodTemplate(in *corev1.PodTemplate) {
        SetDefaults_PodSpec(&in.Template.Spec)
        for i := range in.Template.Spec.Volumes {
                a := &in.Template.Spec.Volumes[i]
                SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Template.Spec.InitContainers {
                a := &in.Template.Spec.InitContainers[i]
                SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                SetDefaults_ResourceList(&a.Resources.Limits)
                SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Template.Spec.Containers {
                a := &in.Template.Spec.Containers[i]
                SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                SetDefaults_ResourceList(&a.Resources.Limits)
                SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Template.Spec.EphemeralContainers {
                a := &in.Template.Spec.EphemeralContainers[i]
                SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        SetDefaults_ResourceList(&in.Template.Spec.Overhead)
        if in.Template.Spec.Resources != nil {
                SetDefaults_ResourceList(&in.Template.Spec.Resources.Limits)
                SetDefaults_ResourceList(&in.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_PodTemplateList(in *corev1.PodTemplateList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_PodTemplate(a)
        }
}

func SetObjectDefaults_ReplicationController(in *corev1.ReplicationController) {
        SetDefaults_ReplicationController(in)
        if in.Spec.Replicas == nil {
                var ptrVar1 int32 = 1
                in.Spec.Replicas = &ptrVar1
        }
        if in.Spec.Template != nil {
                SetDefaults_PodSpec(&in.Spec.Template.Spec)
                for i := range in.Spec.Template.Spec.Volumes {
                        a := &in.Spec.Template.Spec.Volumes[i]
                        SetDefaults_Volume(a)
                        if a.VolumeSource.HostPath != nil {
                                SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                        }
                        if a.VolumeSource.Secret != nil {
                                SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                        }
                        if a.VolumeSource.ISCSI != nil {
                                if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                        a.VolumeSource.ISCSI.ISCSIInterface = "default"
                                }
                        }
                        if a.VolumeSource.RBD != nil {
                                if a.VolumeSource.RBD.RBDPool == "" {
                                        a.VolumeSource.RBD.RBDPool = "rbd"
                                }
                                if a.VolumeSource.RBD.RadosUser == "" {
                                        a.VolumeSource.RBD.RadosUser = "admin"
                                }
                                if a.VolumeSource.RBD.Keyring == "" {
                                        a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                                }
                        }
                        if a.VolumeSource.DownwardAPI != nil {
                                SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                                for j := range a.VolumeSource.DownwardAPI.Items {
                                        b := &a.VolumeSource.DownwardAPI.Items[j]
                                        if b.FieldRef != nil {
                                                SetDefaults_ObjectFieldSelector(b.FieldRef)
                                        }
                                }
                        }
                        if a.VolumeSource.ConfigMap != nil {
                                SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                        }
                        if a.VolumeSource.AzureDisk != nil {
                                if a.VolumeSource.AzureDisk.CachingMode == nil {
                                        ptrVar1 := corev1.AzureDataDiskCachingMode(corev1.AzureDataDiskCachingReadWrite)
                                        a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                                }
                                if a.VolumeSource.AzureDisk.FSType == nil {
                                        var ptrVar1 string = "ext4"
                                        a.VolumeSource.AzureDisk.FSType = &ptrVar1
                                }
                                if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                        var ptrVar1 bool = false
                                        a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                                }
                                if a.VolumeSource.AzureDisk.Kind == nil {
                                        ptrVar1 := corev1.AzureDataDiskKind(corev1.AzureSharedBlobDisk)
                                        a.VolumeSource.AzureDisk.Kind = &ptrVar1
                                }
                        }
                        if a.VolumeSource.Projected != nil {
                                SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                                for j := range a.VolumeSource.Projected.Sources {
                                        b := &a.VolumeSource.Projected.Sources[j]
                                        if b.DownwardAPI != nil {
                                                for k := range b.DownwardAPI.Items {
                                                        c := &b.DownwardAPI.Items[k]
                                                        if c.FieldRef != nil {
                                                                SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                        }
                                                }
                                        }
                                        if b.ServiceAccountToken != nil {
                                                SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                        }
                                }
                        }
                        if a.VolumeSource.ScaleIO != nil {
                                if a.VolumeSource.ScaleIO.StorageMode == "" {
                                        a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                                }
                                if a.VolumeSource.ScaleIO.FSType == "" {
                                        a.VolumeSource.ScaleIO.FSType = "xfs"
                                }
                        }
                        if a.VolumeSource.Ephemeral != nil {
                                if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                        SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                        SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                        SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                                }
                        }
                }
                for i := range in.Spec.Template.Spec.InitContainers {
                        a := &in.Spec.Template.Spec.InitContainers[i]
                        SetDefaults_Container(a)
                        for j := range a.Ports {
                                b := &a.Ports[j]
                                if b.Protocol == "" {
                                        b.Protocol = "TCP"
                                }
                        }
                        for j := range a.Env {
                                b := &a.Env[j]
                                if b.ValueFrom != nil {
                                        if b.ValueFrom.FieldRef != nil {
                                                SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                        }
                                        if b.ValueFrom.FileKeyRef != nil {
                                                if b.ValueFrom.FileKeyRef.Optional == nil {
                                                        var ptrVar1 bool = false
                                                        b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                                }
                                        }
                                }
                        }
                        SetDefaults_ResourceList(&a.Resources.Limits)
                        SetDefaults_ResourceList(&a.Resources.Requests)
                        if a.LivenessProbe != nil {
                                SetDefaults_Probe(a.LivenessProbe)
                                if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                                }
                                if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                        if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.ReadinessProbe != nil {
                                SetDefaults_Probe(a.ReadinessProbe)
                                if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                                }
                                if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                        if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.StartupProbe != nil {
                                SetDefaults_Probe(a.StartupProbe)
                                if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                                }
                                if a.StartupProbe.ProbeHandler.GRPC != nil {
                                        if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.Lifecycle != nil {
                                if a.Lifecycle.PostStart != nil {
                                        if a.Lifecycle.PostStart.HTTPGet != nil {
                                                SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                        }
                                }
                                if a.Lifecycle.PreStop != nil {
                                        if a.Lifecycle.PreStop.HTTPGet != nil {
                                                SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                        }
                                }
                        }
                }
                for i := range in.Spec.Template.Spec.Containers {
                        a := &in.Spec.Template.Spec.Containers[i]
                        SetDefaults_Container(a)
                        for j := range a.Ports {
                                b := &a.Ports[j]
                                if b.Protocol == "" {
                                        b.Protocol = "TCP"
                                }
                        }
                        for j := range a.Env {
                                b := &a.Env[j]
                                if b.ValueFrom != nil {
                                        if b.ValueFrom.FieldRef != nil {
                                                SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                        }
                                        if b.ValueFrom.FileKeyRef != nil {
                                                if b.ValueFrom.FileKeyRef.Optional == nil {
                                                        var ptrVar1 bool = false
                                                        b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                                }
                                        }
                                }
                        }
                        SetDefaults_ResourceList(&a.Resources.Limits)
                        SetDefaults_ResourceList(&a.Resources.Requests)
                        if a.LivenessProbe != nil {
                                SetDefaults_Probe(a.LivenessProbe)
                                if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                                }
                                if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                        if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.ReadinessProbe != nil {
                                SetDefaults_Probe(a.ReadinessProbe)
                                if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                                }
                                if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                        if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.StartupProbe != nil {
                                SetDefaults_Probe(a.StartupProbe)
                                if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                                }
                                if a.StartupProbe.ProbeHandler.GRPC != nil {
                                        if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.Lifecycle != nil {
                                if a.Lifecycle.PostStart != nil {
                                        if a.Lifecycle.PostStart.HTTPGet != nil {
                                                SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                        }
                                }
                                if a.Lifecycle.PreStop != nil {
                                        if a.Lifecycle.PreStop.HTTPGet != nil {
                                                SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                        }
                                }
                        }
                }
                for i := range in.Spec.Template.Spec.EphemeralContainers {
                        a := &in.Spec.Template.Spec.EphemeralContainers[i]
                        SetDefaults_EphemeralContainer(a)
                        for j := range a.EphemeralContainerCommon.Ports {
                                b := &a.EphemeralContainerCommon.Ports[j]
                                if b.Protocol == "" {
                                        b.Protocol = "TCP"
                                }
                        }
                        for j := range a.EphemeralContainerCommon.Env {
                                b := &a.EphemeralContainerCommon.Env[j]
                                if b.ValueFrom != nil {
                                        if b.ValueFrom.FieldRef != nil {
                                                SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                        }
                                        if b.ValueFrom.FileKeyRef != nil {
                                                if b.ValueFrom.FileKeyRef.Optional == nil {
                                                        var ptrVar1 bool = false
                                                        b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                                }
                                        }
                                }
                        }
                        SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                        SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                        if a.EphemeralContainerCommon.LivenessProbe != nil {
                                SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                                }
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe != nil {
                                SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                                }
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.EphemeralContainerCommon.StartupProbe != nil {
                                SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                        SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                                }
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                                var ptrVar1 string = ""
                                                a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                        }
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                        if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                                SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                        }
                                }
                                if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                        if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                                SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                        }
                                }
                        }
                }
                SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
                if in.Spec.Template.Spec.Resources != nil {
                        SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                        SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
                }
        }
}

func SetObjectDefaults_ReplicationControllerList(in *corev1.ReplicationControllerList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ReplicationController(a)
        }
}

func SetObjectDefaults_ResourceQuota(in *corev1.ResourceQuota) {
        SetDefaults_ResourceList(&in.Spec.Hard)
        SetDefaults_ResourceList(&in.Status.Hard)
        SetDefaults_ResourceList(&in.Status.Used)
}

func SetObjectDefaults_ResourceQuotaList(in *corev1.ResourceQuotaList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ResourceQuota(a)
        }
}

func SetObjectDefaults_Secret(in *corev1.Secret) {
        SetDefaults_Secret(in)
}

func SetObjectDefaults_SecretList(in *corev1.SecretList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Secret(a)
        }
}

func SetObjectDefaults_Service(in *corev1.Service) {
        SetDefaults_Service(in)
        for i := range in.Spec.Ports {
                a := &in.Spec.Ports[i]
                if a.Protocol == "" {
                        a.Protocol = "TCP"
                }
        }
}

func SetObjectDefaults_ServiceList(in *corev1.ServiceList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Service(a)
        }
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 validation-gen. DO NOT EDIT.

package v1

import (
        context "context"
        fmt "fmt"

        corev1 "k8s.io/api/core/v1"
        equality "k8s.io/apimachinery/pkg/api/equality"
        operation "k8s.io/apimachinery/pkg/api/operation"
        safe "k8s.io/apimachinery/pkg/api/safe"
        validate "k8s.io/apimachinery/pkg/api/validate"
        runtime "k8s.io/apimachinery/pkg/runtime"
        field "k8s.io/apimachinery/pkg/util/validation/field"
)

func init() { localSchemeBuilder.Register(RegisterValidations) }

// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
        scheme.AddValidationFunc((*corev1.ReplicationController)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/", "/scale":
                        return Validate_ReplicationController(ctx, op, nil /* fldPath */, obj.(*corev1.ReplicationController), safe.Cast[*corev1.ReplicationController](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        scheme.AddValidationFunc((*corev1.ReplicationControllerList)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
                switch op.Request.SubresourcePath() {
                case "/":
                        return Validate_ReplicationControllerList(ctx, op, nil /* fldPath */, obj.(*corev1.ReplicationControllerList), safe.Cast[*corev1.ReplicationControllerList](oldObj))
                }
                return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
        })
        return nil
}

func Validate_ReplicationController(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *corev1.ReplicationController) (errs field.ErrorList) {
        // field corev1.ReplicationController.TypeMeta has no validation
        // field corev1.ReplicationController.ObjectMeta has no validation

        // field corev1.ReplicationController.Spec
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *corev1.ReplicationControllerSpec) (errs field.ErrorList) {
                        errs = append(errs, Validate_ReplicationControllerSpec(ctx, op, fldPath, obj, oldObj)...)
                        return
                }(fldPath.Child("spec"), &obj.Spec, safe.Field(oldObj, func(oldObj *corev1.ReplicationController) *corev1.ReplicationControllerSpec { return &oldObj.Spec }))...)

        // field corev1.ReplicationController.Status has no validation
        return errs
}

func Validate_ReplicationControllerList(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *corev1.ReplicationControllerList) (errs field.ErrorList) {
        // field corev1.ReplicationControllerList.TypeMeta has no validation
        // field corev1.ReplicationControllerList.ListMeta has no validation

        // field corev1.ReplicationControllerList.Items
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj []corev1.ReplicationController) (errs field.ErrorList) {
                        if op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
                                return nil // no changes
                        }
                        errs = append(errs, validate.EachSliceVal(ctx, op, fldPath, obj, oldObj, nil, nil, Validate_ReplicationController)...)
                        return
                }(fldPath.Child("items"), obj.Items, safe.Field(oldObj, func(oldObj *corev1.ReplicationControllerList) []corev1.ReplicationController { return oldObj.Items }))...)

        return errs
}

func Validate_ReplicationControllerSpec(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *corev1.ReplicationControllerSpec) (errs field.ErrorList) {
        // field corev1.ReplicationControllerSpec.Replicas
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *int32) (errs field.ErrorList) {
                        if op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
                                return nil // no changes
                        }
                        // optional fields with default values are effectively required
                        if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj); len(e) != 0 {
                                errs = append(errs, e...)
                                return // do not proceed
                        }
                        errs = append(errs, validate.Minimum(ctx, op, fldPath, obj, oldObj, 0)...)
                        return
                }(fldPath.Child("replicas"), obj.Replicas, safe.Field(oldObj, func(oldObj *corev1.ReplicationControllerSpec) *int32 { return oldObj.Replicas }))...)

        // field corev1.ReplicationControllerSpec.MinReadySeconds
        errs = append(errs,
                func(fldPath *field.Path, obj, oldObj *int32) (errs field.ErrorList) {
                        // optional value-type fields with zero-value defaults are purely documentation
                        if op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
                                return nil // no changes
                        }
                        errs = append(errs, validate.Minimum(ctx, op, fldPath, obj, oldObj, 0)...)
                        return
                }(fldPath.Child("minReadySeconds"), &obj.MinReadySeconds, safe.Field(oldObj, func(oldObj *corev1.ReplicationControllerSpec) *int32 { return &oldObj.MinReadySeconds }))...)

        // field corev1.ReplicationControllerSpec.Selector has no validation
        // field corev1.ReplicationControllerSpec.Template has no validation
        return errs
}

/*
Copyright 2014 The Kubernetes Authors.

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.
*/

package validation

import (
        "fmt"
        "reflect"
        "time"

        v1 "k8s.io/api/core/v1"
        eventsv1beta1 "k8s.io/api/events/v1beta1"
        apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
        "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
        "k8s.io/kubernetes/pkg/apis/core"
)

const (
        ReportingInstanceLengthLimit = 128
        ActionLengthLimit            = 128
        ReasonLengthLimit            = 128
        NoteLengthLimit              = 1024
)

func ValidateEventCreate(event *core.Event, requestVersion schema.GroupVersion) field.ErrorList {
        // Make sure events always pass legacy validation.
        allErrs := legacyValidateEvent(event, requestVersion)
        if requestVersion == v1.SchemeGroupVersion || requestVersion == eventsv1beta1.SchemeGroupVersion {
                // No further validation for backwards compatibility.
                return allErrs
        }

        // Strict validation applies to creation via events.k8s.io/v1 API and newer.
        allErrs = append(allErrs, ValidateObjectMeta(&event.ObjectMeta, true, apimachineryvalidation.NameIsDNSSubdomain, field.NewPath("metadata"))...)
        allErrs = append(allErrs, validateV1EventSeries(event)...)
        zeroTime := time.Time{}
        if event.EventTime.Time == zeroTime {
                allErrs = append(allErrs, field.Required(field.NewPath("eventTime"), ""))
        }
        if event.Type != v1.EventTypeNormal && event.Type != v1.EventTypeWarning {
                allErrs = append(allErrs, field.Invalid(field.NewPath("type"), "", fmt.Sprintf("has invalid value: %v", event.Type)))
        }
        if event.FirstTimestamp.Time != zeroTime {
                allErrs = append(allErrs, field.Invalid(field.NewPath("firstTimestamp"), "", "needs to be unset"))
        }
        if event.LastTimestamp.Time != zeroTime {
                allErrs = append(allErrs, field.Invalid(field.NewPath("lastTimestamp"), "", "needs to be unset"))
        }
        if event.Count != 0 {
                allErrs = append(allErrs, field.Invalid(field.NewPath("count"), "", "needs to be unset"))
        }
        if event.Source.Component != "" || event.Source.Host != "" {
                allErrs = append(allErrs, field.Invalid(field.NewPath("source"), "", "needs to be unset"))
        }
        return allErrs
}

func ValidateEventUpdate(newEvent, oldEvent *core.Event, requestVersion schema.GroupVersion) field.ErrorList {
        // Make sure the new event always passes legacy validation.
        allErrs := legacyValidateEvent(newEvent, requestVersion)
        if requestVersion == v1.SchemeGroupVersion || requestVersion == eventsv1beta1.SchemeGroupVersion {
                // No further validation for backwards compatibility.
                return allErrs
        }

        // Strict validation applies to update via events.k8s.io/v1 API and newer.
        allErrs = append(allErrs, ValidateObjectMetaUpdate(&newEvent.ObjectMeta, &oldEvent.ObjectMeta, field.NewPath("metadata"))...)
        // if the series was modified, validate the new data
        if !reflect.DeepEqual(newEvent.Series, oldEvent.Series) {
                allErrs = append(allErrs, validateV1EventSeries(newEvent)...)
        }

        allErrs = append(allErrs, ValidateImmutableField(newEvent.InvolvedObject, oldEvent.InvolvedObject, field.NewPath("involvedObject"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.Reason, oldEvent.Reason, field.NewPath("reason"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.Message, oldEvent.Message, field.NewPath("message"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.Source, oldEvent.Source, field.NewPath("source"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.FirstTimestamp, oldEvent.FirstTimestamp, field.NewPath("firstTimestamp"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.LastTimestamp, oldEvent.LastTimestamp, field.NewPath("lastTimestamp"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.Count, oldEvent.Count, field.NewPath("count"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.Reason, oldEvent.Reason, field.NewPath("reason"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.Type, oldEvent.Type, field.NewPath("type"))...)

        // Disallow changes to eventTime greater than microsecond-level precision.
        // Tolerating sub-microsecond changes is required to tolerate updates
        // from clients that correctly truncate to microsecond-precision when serializing,
        // or from clients built with incorrect nanosecond-precision protobuf serialization.
        // See https://github.com/kubernetes/kubernetes/issues/111928
        newTruncated := newEvent.EventTime.Truncate(time.Microsecond).UTC()
        oldTruncated := oldEvent.EventTime.Truncate(time.Microsecond).UTC()
        if newTruncated != oldTruncated {
                allErrs = append(allErrs, ValidateImmutableField(newEvent.EventTime, oldEvent.EventTime, field.NewPath("eventTime"))...)
        }

        allErrs = append(allErrs, ValidateImmutableField(newEvent.Action, oldEvent.Action, field.NewPath("action"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.Related, oldEvent.Related, field.NewPath("related"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.ReportingController, oldEvent.ReportingController, field.NewPath("reportingController"))...)
        allErrs = append(allErrs, ValidateImmutableField(newEvent.ReportingInstance, oldEvent.ReportingInstance, field.NewPath("reportingInstance"))...)

        return allErrs
}

func validateV1EventSeries(event *core.Event) field.ErrorList {
        allErrs := field.ErrorList{}
        zeroTime := time.Time{}
        if event.Series != nil {
                if event.Series.Count < 2 {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("series.count"), "", "should be at least 2"))
                }
                if event.Series.LastObservedTime.Time == zeroTime {
                        allErrs = append(allErrs, field.Required(field.NewPath("series.lastObservedTime"), ""))
                }
        }
        return allErrs
}

// legacyValidateEvent makes sure that the event makes sense.
func legacyValidateEvent(event *core.Event, requestVersion schema.GroupVersion) field.ErrorList {
        allErrs := field.ErrorList{}
        // Because go
        zeroTime := time.Time{}

        reportingControllerFieldName := "reportingController"
        if requestVersion == v1.SchemeGroupVersion {
                reportingControllerFieldName = "reportingComponent"
        }

        // "New" Events need to have EventTime set, so it's validating old object.
        if event.EventTime.Time == zeroTime {
                // Make sure event.Namespace and the involvedInvolvedObject.Namespace agree
                if len(event.InvolvedObject.Namespace) == 0 {
                        // event.Namespace must also be empty (or "default", for compatibility with old clients)
                        if event.Namespace != metav1.NamespaceNone && event.Namespace != metav1.NamespaceDefault {
                                allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
                        }
                } else {
                        // event namespace must match
                        if event.Namespace != event.InvolvedObject.Namespace {
                                allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
                        }
                }

        } else {
                if len(event.InvolvedObject.Namespace) == 0 && event.Namespace != metav1.NamespaceDefault && event.Namespace != metav1.NamespaceSystem {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
                }
                if len(event.ReportingController) == 0 {
                        allErrs = append(allErrs, field.Required(field.NewPath(reportingControllerFieldName), ""))
                }
                allErrs = append(allErrs, ValidateQualifiedName(event.ReportingController, field.NewPath(reportingControllerFieldName))...)
                if len(event.ReportingInstance) == 0 {
                        allErrs = append(allErrs, field.Required(field.NewPath("reportingInstance"), ""))
                }
                if len(event.ReportingInstance) > ReportingInstanceLengthLimit {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("reportingInstance"), "", fmt.Sprintf("can have at most %v characters", ReportingInstanceLengthLimit)))
                }
                if len(event.Action) == 0 {
                        allErrs = append(allErrs, field.Required(field.NewPath("action"), ""))
                }
                if len(event.Action) > ActionLengthLimit {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("action"), "", fmt.Sprintf("can have at most %v characters", ActionLengthLimit)))
                }
                if len(event.Reason) == 0 {
                        allErrs = append(allErrs, field.Required(field.NewPath("reason"), ""))
                }
                if len(event.Reason) > ReasonLengthLimit {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("reason"), "", fmt.Sprintf("can have at most %v characters", ReasonLengthLimit)))
                }
                if len(event.Message) > NoteLengthLimit {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("message"), "", fmt.Sprintf("can have at most %v characters", NoteLengthLimit)))
                }
        }

        for _, msg := range validation.IsDNS1123Subdomain(event.Namespace) {
                allErrs = append(allErrs, field.Invalid(field.NewPath("namespace"), event.Namespace, msg))
        }
        return allErrs
}

/*
Copyright 2023 The Kubernetes Authors.

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.
*/

package validation

import (
        "fmt"
        "strings"

        apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
        "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
)

// IsKubernetesSignerName checks if signerName is one reserved by the Kubernetes project.
func IsKubernetesSignerName(signerName string) bool {
        hostName, _, _ := strings.Cut(signerName, "/")
        return hostName == "kubernetes.io" || strings.HasSuffix(hostName, ".kubernetes.io")
}

// ValidateSignerName checks that signerName is syntactically valid.
//
// ensure signerName is of the form domain.com/something and up to 571 characters.
// This length and format is specified to accommodate signerNames like:
// <fqdn>/<resource-namespace>.<resource-name>.
// The max length of a FQDN is 253 characters (DNS1123Subdomain max length)
// The max length of a namespace name is 63 characters (DNS1123Label max length)
// The max length of a resource name is 253 characters (DNS1123Subdomain max length)
// We then add an additional 2 characters to account for the one '.' and one '/'.
func ValidateSignerName(fldPath *field.Path, signerName string) field.ErrorList {
        var el field.ErrorList
        if len(signerName) == 0 {
                el = append(el, field.Required(fldPath, ""))
                return el
        }

        segments := strings.Split(signerName, "/")
        // validate that there is one '/' in the signerName.
        // we do this after validating the domain segment to provide more info to the user.
        if len(segments) != 2 {
                el = append(el, field.Invalid(fldPath, signerName, "must be a fully qualified domain and path of the form 'example.com/signer-name'"))
                // return early here as we should not continue attempting to validate a missing or malformed path segment
                // (i.e. one containing multiple or zero `/`)
                return el
        }

        // validate that segments[0] is less than 253 characters altogether
        maxDomainSegmentLength := validation.DNS1123SubdomainMaxLength
        if len(segments[0]) > maxDomainSegmentLength {
                el = append(el, field.TooLong(fldPath, "" /*unused*/, maxDomainSegmentLength))
        }
        // validate that segments[0] consists of valid DNS1123 labels separated by '.'
        domainLabels := strings.Split(segments[0], ".")
        for _, lbl := range domainLabels {
                // use IsDNS1123Label as we want to ensure the max length of any single label in the domain
                // is 63 characters
                if errs := validation.IsDNS1123Label(lbl); len(errs) > 0 {
                        for _, err := range errs {
                                el = append(el, field.Invalid(fldPath, segments[0], fmt.Sprintf("validating label %q: %s", lbl, err)))
                        }
                        // if we encounter any errors whilst parsing the domain segment, break from
                        // validation as any further error messages will be duplicates, and non-distinguishable
                        // from each other, confusing users.
                        break
                }
        }

        // validate that there is at least one '.' in segments[0]
        if len(domainLabels) < 2 {
                el = append(el, field.Invalid(fldPath, segments[0], "should be a domain with at least two segments separated by dots"))
        }

        // validate that segments[1] consists of valid DNS1123 subdomains separated by '.'.
        pathLabels := strings.Split(segments[1], ".")
        for _, lbl := range pathLabels {
                // use IsDNS1123Subdomain because it enforces a length restriction of 253 characters
                // which is required in order to fit a full resource name into a single 'label'
                if errs := validation.IsDNS1123Subdomain(lbl); len(errs) > 0 {
                        for _, err := range errs {
                                el = append(el, field.Invalid(fldPath, segments[1], fmt.Sprintf("validating label %q: %s", lbl, err)))
                        }
                        // if we encounter any errors whilst parsing the path segment, break from
                        // validation as any further error messages will be duplicates, and non-distinguishable
                        // from each other, confusing users.
                        break
                }
        }

        // ensure that segments[1] can accommodate a dns label + dns subdomain + '.'
        maxPathSegmentLength := validation.DNS1123SubdomainMaxLength + validation.DNS1123LabelMaxLength + 1
        maxSignerNameLength := maxDomainSegmentLength + maxPathSegmentLength + 1
        if len(signerName) > maxSignerNameLength {
                el = append(el, field.TooLong(fldPath, "" /*unused*/, maxSignerNameLength))
        }

        return el
}

// ValidateClusterTrustBundleName checks that a ClusterTrustBundle name conforms
// to the rules documented on the type.
func ValidateClusterTrustBundleName(signerName string) func(name string, prefix bool) []string {
        return func(name string, isPrefix bool) []string {
                if signerName == "" {
                        if strings.Contains(name, ":") {
                                return []string{"ClusterTrustBundle without signer name must not have \":\" in its name"}
                        }
                        return apimachineryvalidation.NameIsDNSSubdomain(name, isPrefix)
                }

                requiredPrefix := strings.ReplaceAll(signerName, "/", ":") + ":"
                if !strings.HasPrefix(name, requiredPrefix) {
                        return []string{fmt.Sprintf("ClusterTrustBundle for signerName %s must be named with prefix %s", signerName, requiredPrefix)}
                }
                return apimachineryvalidation.NameIsDNSSubdomain(strings.TrimPrefix(name, requiredPrefix), isPrefix)
        }
}

func extractSignerNameFromClusterTrustBundleName(name string) (string, bool) {
        if splitPoint := strings.LastIndex(name, ":"); splitPoint != -1 {
                // This looks like it refers to a signerName trustbundle.
                return strings.ReplaceAll(name[:splitPoint], ":", "/"), true
        } else {
                return "", false
        }
}

/*
Copyright 2014 The Kubernetes Authors.

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.
*/

package validation

import (
        "encoding/json"
        "fmt"
        "math"
        "net"
        "path"
        "path/filepath"
        "reflect"
        "regexp"
        "slices"
        "strings"
        "sync"
        "unicode"
        "unicode/utf8"

        netutils "k8s.io/utils/net"

        v1 "k8s.io/api/core/v1"
        apiequality "k8s.io/apimachinery/pkg/api/equality"
        "k8s.io/apimachinery/pkg/api/resource"
        apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        unversionedvalidation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/apimachinery/pkg/util/diff"
        "k8s.io/apimachinery/pkg/util/intstr"
        "k8s.io/apimachinery/pkg/util/sets"
        "k8s.io/apimachinery/pkg/util/validation"
        "k8s.io/apimachinery/pkg/util/validation/field"
        utilfeature "k8s.io/apiserver/pkg/util/feature"
        utilsysctl "k8s.io/component-helpers/node/util/sysctl"
        resourcehelper "k8s.io/component-helpers/resource"
        schedulinghelper "k8s.io/component-helpers/scheduling/corev1"
        kubeletapis "k8s.io/kubelet/pkg/apis"
        "k8s.io/kubernetes/pkg/apis/certificates"

        apiservice "k8s.io/kubernetes/pkg/api/service"
        podutil "k8s.io/kubernetes/pkg/api/v1/pod"
        "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/core/helper"
        "k8s.io/kubernetes/pkg/apis/core/helper/qos"
        podshelper "k8s.io/kubernetes/pkg/apis/core/pods"
        corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
        "k8s.io/kubernetes/pkg/capabilities"
        "k8s.io/kubernetes/pkg/features"
        "k8s.io/kubernetes/pkg/fieldpath"
)

const isNegativeErrorMsg string = apimachineryvalidation.IsNegativeErrorMsg
const isInvalidQuotaResource string = `must be a standard resource for quota`
const fieldImmutableErrorMsg string = apimachineryvalidation.FieldImmutableErrorMsg
const isNotIntegerErrorMsg string = `must be an integer`
const isNotPositiveErrorMsg string = `must be greater than zero`

var pdPartitionErrorMsg string = validation.InclusiveRangeError(1, 255)
var fileModeErrorMsg = "must be a number between 0 and 0777 (octal), both inclusive"

// BannedOwners is a black list of object that are not allowed to be owners.
var BannedOwners = apimachineryvalidation.BannedOwners

var iscsiInitiatorIqnRegex = regexp.MustCompile(`iqn\.\d{4}-\d{2}\.([[:alnum:]-.]+)(:[^,;*&$|\s]+)$`)
var iscsiInitiatorEuiRegex = regexp.MustCompile(`^eui.[[:alnum:]]{16}$`)
var iscsiInitiatorNaaRegex = regexp.MustCompile(`^naa.[[:alnum:]]{32}$`)

var allowedEphemeralContainerFields = map[string]bool{
        "Name":                     true,
        "Image":                    true,
        "Command":                  true,
        "Args":                     true,
        "WorkingDir":               true,
        "Ports":                    false,
        "EnvFrom":                  true,
        "Env":                      true,
        "Resources":                false,
        "VolumeMounts":             true,
        "VolumeDevices":            true,
        "LivenessProbe":            false,
        "ReadinessProbe":           false,
        "StartupProbe":             false,
        "Lifecycle":                false,
        "TerminationMessagePath":   true,
        "TerminationMessagePolicy": true,
        "ImagePullPolicy":          true,
        "SecurityContext":          true,
        "Stdin":                    true,
        "StdinOnce":                true,
        "TTY":                      true,
}

// validOS stores the set of valid OSes within pod spec.
// The valid values currently are linux, windows.
// In future, they can be expanded to values from
// https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration
var validOS = sets.New(core.Linux, core.Windows)

// ValidateHasLabel requires that metav1.ObjectMeta has a Label with key and expectedValue
func ValidateHasLabel(meta metav1.ObjectMeta, fldPath *field.Path, key, expectedValue string) field.ErrorList {
        allErrs := field.ErrorList{}
        actualValue, found := meta.Labels[key]
        if !found {
                allErrs = append(allErrs, field.Required(fldPath.Child("labels").Key(key),
                        fmt.Sprintf("must be '%s'", expectedValue)))
                return allErrs
        }
        if actualValue != expectedValue {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("labels").Key(key), meta.Labels,
                        fmt.Sprintf("must be '%s'", expectedValue)))
        }
        return allErrs
}

// ValidateAnnotations validates that a set of annotations are correctly defined.
func ValidateAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
        return apimachineryvalidation.ValidateAnnotations(annotations, fldPath)
}

func ValidateDNS1123Label(value string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, msg := range validation.IsDNS1123Label(value) {
                allErrs = append(allErrs, field.Invalid(fldPath, value, msg).WithOrigin("format=dns-label"))
        }
        return allErrs
}

// ValidateQualifiedName validates if name is what Kubernetes calls a "qualified name".
func ValidateQualifiedName(value string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, msg := range validation.IsQualifiedName(value) {
                allErrs = append(allErrs, field.Invalid(fldPath, value, msg).WithOrigin("format=qualified-name"))
        }
        return allErrs
}

// ValidateDNS1123SubdomainWithUnderScore validates that a name is a proper DNS subdomain but allows for an underscore in the string
func ValidateDNS1123SubdomainWithUnderScore(value string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, msg := range validation.IsDNS1123SubdomainWithUnderscore(value) {
                allErrs = append(allErrs, field.Invalid(fldPath, value, msg)).WithOrigin("format=k8s-dns-subdomain-with-underscore")
        }
        return allErrs
}

// ValidateDNS1123Subdomain validates that a name is a proper DNS subdomain.
func ValidateDNS1123Subdomain(value string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, msg := range validation.IsDNS1123Subdomain(value) {
                allErrs = append(allErrs, field.Invalid(fldPath, value, msg)).WithOrigin("format=k8s-long-name")
        }
        return allErrs
}

func ValidatePodSpecificAnnotations(annotations map[string]string, spec *core.PodSpec, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if value, isMirror := annotations[core.MirrorPodAnnotationKey]; isMirror {
                if len(spec.NodeName) == 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Key(core.MirrorPodAnnotationKey), value, "must set spec.nodeName if mirror pod annotation is set"))
                }
        }

        if annotations[core.TolerationsAnnotationKey] != "" {
                allErrs = append(allErrs, ValidateTolerationsInPodAnnotations(annotations, fldPath)...)
        }

        if !opts.AllowInvalidPodDeletionCost {
                if _, err := helper.GetDeletionCostFromPodAnnotations(annotations); err != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath.Key(core.PodDeletionCost), annotations[core.PodDeletionCost], "must be a 32bit integer"))
                }
        }

        allErrs = append(allErrs, ValidateSeccompPodAnnotations(annotations, fldPath)...)
        allErrs = append(allErrs, ValidateAppArmorPodAnnotations(annotations, spec, fldPath)...)

        return allErrs
}

// ValidateTolerationsInPodAnnotations tests that the serialized tolerations in Pod.Annotations has valid data
func ValidateTolerationsInPodAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        tolerations, err := helper.GetTolerationsFromPodAnnotations(annotations)
        if err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath, core.TolerationsAnnotationKey, err.Error()))
                return allErrs
        }

        if len(tolerations) > 0 {
                allErrs = append(allErrs, ValidateTolerations(tolerations, fldPath.Child(core.TolerationsAnnotationKey))...)
        }

        return allErrs
}

func ValidatePodSpecificAnnotationUpdates(newPod, oldPod *core.Pod, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        newAnnotations := newPod.Annotations
        oldAnnotations := oldPod.Annotations
        for k, oldVal := range oldAnnotations {
                if newVal, exists := newAnnotations[k]; exists && newVal == oldVal {
                        continue // No change.
                }
                if strings.HasPrefix(k, v1.DeprecatedAppArmorBetaContainerAnnotationKeyPrefix) {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Key(k), "may not remove or update AppArmor annotations"))
                }
                if k == core.MirrorPodAnnotationKey {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Key(k), "may not remove or update mirror pod annotation"))
                }
        }
        // Check for additions
        for k := range newAnnotations {
                if _, ok := oldAnnotations[k]; ok {
                        continue // No change.
                }
                if strings.HasPrefix(k, v1.DeprecatedAppArmorBetaContainerAnnotationKeyPrefix) {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Key(k), "may not add AppArmor annotations"))
                }
                if k == core.MirrorPodAnnotationKey {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Key(k), "may not add mirror pod annotation"))
                }
        }
        allErrs = append(allErrs, ValidatePodSpecificAnnotations(newAnnotations, &newPod.Spec, fldPath, opts)...)
        return allErrs
}

func ValidateEndpointsSpecificAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        return allErrs
}

// ValidateNameFunc validates that the provided name is valid for a given resource type.
// Not all resources have the same validation rules for names. Prefix is true
// if the name will have a value appended to it.  If the name is not valid,
// this returns a list of descriptions of individual characteristics of the
// value that were not valid.  Otherwise this returns an empty list or nil.
type ValidateNameFunc apimachineryvalidation.ValidateNameFunc

// ValidatePodName can be used to check whether the given pod name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidatePodName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateReplicationControllerName can be used to check whether the given replication
// controller name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateReplicationControllerName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateServiceName can be used to check whether the given service name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateServiceName = apimachineryvalidation.NameIsDNS1035Label

// ValidateNodeName can be used to check whether the given node name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateNodeName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateNamespaceName can be used to check whether the given namespace name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateNamespaceName = apimachineryvalidation.ValidateNamespaceName

// ValidateLimitRangeName can be used to check whether the given limit range name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateLimitRangeName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateResourceQuotaName can be used to check whether the given
// resource quota name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateResourceQuotaName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateSecretName can be used to check whether the given secret name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateSecretName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateServiceAccountName can be used to check whether the given service account name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateServiceAccountName = apimachineryvalidation.ValidateServiceAccountName

// ValidateEndpointsName can be used to check whether the given endpoints name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateEndpointsName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateClassName can be used to check whether the given class name is valid.
// It is defined here to avoid import cycle between pkg/apis/storage/validation
// (where it should be) and this file.
var ValidateClassName = apimachineryvalidation.NameIsDNSSubdomain

// ValidatePriorityClassName can be used to check whether the given priority
// class name is valid.
var ValidatePriorityClassName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateResourceClaimName can be used to check whether the given
// name for a ResourceClaim is valid.
var ValidateResourceClaimName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateResourceClaimTemplateName can be used to check whether the given
// name for a ResourceClaimTemplate is valid.
var ValidateResourceClaimTemplateName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateRuntimeClassName can be used to check whether the given RuntimeClass name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
func ValidateRuntimeClassName(name string, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        for _, msg := range apimachineryvalidation.NameIsDNSSubdomain(name, false) {
                allErrs = append(allErrs, field.Invalid(fldPath, name, msg))
        }
        return allErrs
}

// validateOverhead can be used to check whether the given Overhead is valid.
func validateOverhead(overhead core.ResourceList, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        // reuse the ResourceRequirements validation logic
        return ValidateContainerResourceRequirements(&core.ResourceRequirements{Limits: overhead}, nil, fldPath, opts)
}

// Validates that given value is not negative.
func ValidateNonnegativeField(value int64, fldPath *field.Path) field.ErrorList {
        return apimachineryvalidation.ValidateNonnegativeField(value, fldPath)
}

// Validates that a Quantity is not negative
func ValidateNonnegativeQuantity(value resource.Quantity, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if value.Cmp(resource.Quantity{}) < 0 {
                allErrs = append(allErrs, field.Invalid(fldPath, value.String(), isNegativeErrorMsg))
        }
        return allErrs
}

// Validates that given value is positive.
func ValidatePositiveField(value int64, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if value <= 0 {
                allErrs = append(allErrs, field.Invalid(fldPath, value, isNotPositiveErrorMsg).WithOrigin("minimum"))
        }
        return allErrs
}

// Validates that a Quantity is positive
func ValidatePositiveQuantityValue(value resource.Quantity, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if value.Cmp(resource.Quantity{}) <= 0 {
                allErrs = append(allErrs, field.Invalid(fldPath, value.String(), isNotPositiveErrorMsg))
        }
        return allErrs
}

func ValidateImmutableField(newVal, oldVal interface{}, fldPath *field.Path) field.ErrorList {
        return apimachineryvalidation.ValidateImmutableField(newVal, oldVal, fldPath)
}

func ValidateImmutableAnnotation(newVal string, oldVal string, annotation string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if oldVal != newVal {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("annotations", annotation), newVal, fieldImmutableErrorMsg))
        }
        return allErrs
}

// ValidateObjectMeta validates an object's metadata on creation. It expects that name generation has already
// been performed.
// It doesn't return an error for rootscoped resources with namespace, because namespace should already be cleared before.
// TODO: Remove calls to this method scattered in validations of specific resources, e.g., ValidatePodUpdate.
func ValidateObjectMeta(meta *metav1.ObjectMeta, requiresNamespace bool, nameFn ValidateNameFunc, fldPath *field.Path) field.ErrorList {
        allErrs := apimachineryvalidation.ValidateObjectMeta(meta, requiresNamespace, apimachineryvalidation.ValidateNameFunc(nameFn), fldPath)
        // run additional checks for the finalizer name
        for i := range meta.Finalizers {
                allErrs = append(allErrs, validateKubeFinalizerName(string(meta.Finalizers[i]), fldPath.Child("finalizers").Index(i))...)
        }
        return allErrs
}

// ValidateObjectMetaUpdate validates an object's metadata when updated
func ValidateObjectMetaUpdate(newMeta, oldMeta *metav1.ObjectMeta, fldPath *field.Path) field.ErrorList {
        allErrs := apimachineryvalidation.ValidateObjectMetaUpdate(newMeta, oldMeta, fldPath)
        // run additional checks for the finalizer name
        for i := range newMeta.Finalizers {
                allErrs = append(allErrs, validateKubeFinalizerName(string(newMeta.Finalizers[i]), fldPath.Child("finalizers").Index(i))...)
        }

        return allErrs
}

func ValidateVolumes(volumes []core.Volume, podMeta *metav1.ObjectMeta, fldPath *field.Path, opts PodValidationOptions) (map[string]core.VolumeSource, field.ErrorList) {
        allErrs := field.ErrorList{}

        allNames := sets.Set[string]{}
        allCreatedPVCs := sets.Set[string]{}
        // Determine which PVCs will be created for this pod. We need
        // the exact name of the pod for this. Without it, this sanity
        // check has to be skipped.
        if podMeta != nil && podMeta.Name != "" {
                for _, vol := range volumes {
                        if vol.VolumeSource.Ephemeral != nil {
                                allCreatedPVCs.Insert(podMeta.Name + "-" + vol.Name)
                        }
                }
        }
        vols := make(map[string]core.VolumeSource)
        for i, vol := range volumes {
                idxPath := fldPath.Index(i)
                namePath := idxPath.Child("name")
                el := validateVolumeSource(&vol.VolumeSource, idxPath, vol.Name, podMeta, opts)
                if len(vol.Name) == 0 {
                        el = append(el, field.Required(namePath, ""))
                } else {
                        el = append(el, ValidateDNS1123Label(vol.Name, namePath)...)
                }
                if allNames.Has(vol.Name) {
                        el = append(el, field.Duplicate(namePath, vol.Name))
                }
                if len(el) == 0 {
                        allNames.Insert(vol.Name)
                        vols[vol.Name] = vol.VolumeSource
                } else {
                        allErrs = append(allErrs, el...)
                }
                // A PersistentVolumeClaimSource should not reference a created PVC. That doesn't
                // make sense.
                if vol.PersistentVolumeClaim != nil && allCreatedPVCs.Has(vol.PersistentVolumeClaim.ClaimName) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("persistentVolumeClaim").Child("claimName"), vol.PersistentVolumeClaim.ClaimName,
                                "must not reference a PVC that gets created for an ephemeral volume"))
                }
        }

        return vols, allErrs
}

func IsMatchedVolume(name string, volumes map[string]core.VolumeSource) bool {
        if _, ok := volumes[name]; ok {
                return true
        }
        return false
}

// isMatched checks whether the volume with the given name is used by a
// container and if so, if it involves a PVC.
func isMatchedDevice(name string, volumes map[string]core.VolumeSource) (isMatched bool, isPVC bool) {
        if source, ok := volumes[name]; ok {
                if source.PersistentVolumeClaim != nil ||
                        source.Ephemeral != nil {
                        return true, true
                }
                return true, false
        }
        return false, false
}

func mountNameAlreadyExists(name string, devices map[string]string) bool {
        if _, ok := devices[name]; ok {
                return true
        }
        return false
}

func mountPathAlreadyExists(mountPath string, devices map[string]string) bool {
        for _, devPath := range devices {
                if mountPath == devPath {
                        return true
                }
        }

        return false
}

func deviceNameAlreadyExists(name string, mounts map[string]string) bool {
        if _, ok := mounts[name]; ok {
                return true
        }
        return false
}

func devicePathAlreadyExists(devicePath string, mounts map[string]string) bool {
        for _, mountPath := range mounts {
                if mountPath == devicePath {
                        return true
                }
        }

        return false
}

func validateVolumeSource(source *core.VolumeSource, fldPath *field.Path, volName string, podMeta *metav1.ObjectMeta, opts PodValidationOptions) field.ErrorList {
        numVolumes := 0
        allErrs := field.ErrorList{}
        if source.EmptyDir != nil {
                numVolumes++
                if source.EmptyDir.SizeLimit != nil && source.EmptyDir.SizeLimit.Cmp(resource.Quantity{}) < 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("emptyDir").Child("sizeLimit"), "SizeLimit field must be a valid resource quantity"))
                }
        }
        if source.HostPath != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostPath"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateHostPathVolumeSource(source.HostPath, fldPath.Child("hostPath"))...)
                }
        }
        if source.GitRepo != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("gitRepo"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateGitRepoVolumeSource(source.GitRepo, fldPath.Child("gitRepo"))...)
                }
        }
        if source.GCEPersistentDisk != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("gcePersistentDisk"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateGCEPersistentDiskVolumeSource(source.GCEPersistentDisk, fldPath.Child("persistentDisk"))...)
                }
        }
        if source.AWSElasticBlockStore != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("awsElasticBlockStore"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateAWSElasticBlockStoreVolumeSource(source.AWSElasticBlockStore, fldPath.Child("awsElasticBlockStore"))...)
                }
        }
        if source.Secret != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("secret"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateSecretVolumeSource(source.Secret, fldPath.Child("secret"))...)
                }
        }
        if source.NFS != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("nfs"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateNFSVolumeSource(source.NFS, fldPath.Child("nfs"))...)
                }
        }
        if source.ISCSI != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("iscsi"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateISCSIVolumeSource(source.ISCSI, fldPath.Child("iscsi"))...)
                }
                if source.ISCSI.InitiatorName != nil && len(volName+":"+source.ISCSI.TargetPortal) > 64 {
                        tooLongErr := "Total length of <volume name>:<iscsi.targetPortal> must be under 64 characters if iscsi.initiatorName is specified."
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), volName, tooLongErr))
                }
        }
        if source.Glusterfs != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("glusterfs"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateGlusterfsVolumeSource(source.Glusterfs, fldPath.Child("glusterfs"))...)
                }
        }
        if source.Flocker != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("flocker"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateFlockerVolumeSource(source.Flocker, fldPath.Child("flocker"))...)
                }
        }
        if source.PersistentVolumeClaim != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("persistentVolumeClaim"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validatePersistentClaimVolumeSource(source.PersistentVolumeClaim, fldPath.Child("persistentVolumeClaim"))...)
                }
        }
        if source.RBD != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("rbd"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateRBDVolumeSource(source.RBD, fldPath.Child("rbd"))...)
                }
        }
        if source.Cinder != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("cinder"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateCinderVolumeSource(source.Cinder, fldPath.Child("cinder"))...)
                }
        }
        if source.CephFS != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("cephFS"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateCephFSVolumeSource(source.CephFS, fldPath.Child("cephfs"))...)
                }
        }
        if source.Quobyte != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("quobyte"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateQuobyteVolumeSource(source.Quobyte, fldPath.Child("quobyte"))...)
                }
        }
        if source.DownwardAPI != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("downwarAPI"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateDownwardAPIVolumeSource(source.DownwardAPI, fldPath.Child("downwardAPI"), opts)...)
                }
        }
        if source.FC != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("fc"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateFCVolumeSource(source.FC, fldPath.Child("fc"))...)
                }
        }
        if source.FlexVolume != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("flexVolume"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateFlexVolumeSource(source.FlexVolume, fldPath.Child("flexVolume"))...)
                }
        }
        if source.ConfigMap != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("configMap"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateConfigMapVolumeSource(source.ConfigMap, fldPath.Child("configMap"))...)
                }
        }

        if source.AzureFile != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("azureFile"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateAzureFile(source.AzureFile, fldPath.Child("azureFile"))...)
                }
        }

        if source.VsphereVolume != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("vsphereVolume"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateVsphereVolumeSource(source.VsphereVolume, fldPath.Child("vsphereVolume"))...)
                }
        }
        if source.PhotonPersistentDisk != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("photonPersistentDisk"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validatePhotonPersistentDiskVolumeSource(source.PhotonPersistentDisk, fldPath.Child("photonPersistentDisk"))...)
                }
        }
        if source.PortworxVolume != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("portworxVolume"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validatePortworxVolumeSource(source.PortworxVolume, fldPath.Child("portworxVolume"))...)
                }
        }
        if source.AzureDisk != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("azureDisk"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateAzureDisk(source.AzureDisk, fldPath.Child("azureDisk"))...)
                }
        }
        if source.StorageOS != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("storageos"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateStorageOSVolumeSource(source.StorageOS, fldPath.Child("storageos"))...)
                }
        }
        if source.Projected != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("projected"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateProjectedVolumeSource(source.Projected, fldPath.Child("projected"), opts)...)
                }
        }
        if source.ScaleIO != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("scaleIO"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateScaleIOVolumeSource(source.ScaleIO, fldPath.Child("scaleIO"))...)
                }
        }
        if source.CSI != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("csi"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateCSIVolumeSource(source.CSI, fldPath.Child("csi"))...)
                }
        }
        if source.Ephemeral != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("ephemeral"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateEphemeralVolumeSource(source.Ephemeral, fldPath.Child("ephemeral"))...)
                        // Check the expected name for the PVC. This gets skipped if information is missing,
                        // because that already gets flagged as a problem elsewhere. For example,
                        // ValidateObjectMeta as called by validatePodMetadataAndSpec checks that the name is set.
                        if podMeta != nil && podMeta.Name != "" && volName != "" {
                                pvcName := podMeta.Name + "-" + volName
                                for _, msg := range ValidatePersistentVolumeName(pvcName, false) {
                                        allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), volName, fmt.Sprintf("PVC name %q: %v", pvcName, msg)))
                                }
                        }
                }
        }
        if source.Image != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("image"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateImageVolumeSource(source.Image, fldPath.Child("image"), opts)...)
                }
        }

        if numVolumes == 0 {
                allErrs = append(allErrs, field.Required(fldPath, "must specify a volume type"))
        }

        return allErrs
}

func validateHostPathVolumeSource(hostPath *core.HostPathVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(hostPath.Path) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
                return allErrs
        }

        allErrs = append(allErrs, validatePathNoBacksteps(hostPath.Path, fldPath.Child("path"))...)
        allErrs = append(allErrs, validateHostPathType(hostPath.Type, fldPath.Child("type"))...)
        return allErrs
}

func validateGitRepoVolumeSource(gitRepo *core.GitRepoVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(gitRepo.Repository) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("repository"), ""))
        }

        pathErrs := validateLocalDescendingPath(gitRepo.Directory, fldPath.Child("directory"))
        allErrs = append(allErrs, pathErrs...)
        return allErrs
}

func validateISCSIVolumeSource(iscsi *core.ISCSIVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(iscsi.TargetPortal) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("targetPortal"), ""))
        }
        if len(iscsi.IQN) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("iqn"), ""))
        } else {
                if !strings.HasPrefix(iscsi.IQN, "iqn") && !strings.HasPrefix(iscsi.IQN, "eui") && !strings.HasPrefix(iscsi.IQN, "naa") {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("iqn"), iscsi.IQN, "must be valid format starting with iqn, eui, or naa"))
                } else if strings.HasPrefix(iscsi.IQN, "iqn") && !iscsiInitiatorIqnRegex.MatchString(iscsi.IQN) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("iqn"), iscsi.IQN, "must be valid format"))
                } else if strings.HasPrefix(iscsi.IQN, "eui") && !iscsiInitiatorEuiRegex.MatchString(iscsi.IQN) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("iqn"), iscsi.IQN, "must be valid format"))
                } else if strings.HasPrefix(iscsi.IQN, "naa") && !iscsiInitiatorNaaRegex.MatchString(iscsi.IQN) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("iqn"), iscsi.IQN, "must be valid format"))
                }
        }
        if iscsi.Lun < 0 || iscsi.Lun > 255 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("lun"), iscsi.Lun, validation.InclusiveRangeError(0, 255)))
        }
        if (iscsi.DiscoveryCHAPAuth || iscsi.SessionCHAPAuth) && iscsi.SecretRef == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("secretRef"), ""))
        }
        if iscsi.InitiatorName != nil {
                initiator := *iscsi.InitiatorName
                if !strings.HasPrefix(initiator, "iqn") && !strings.HasPrefix(initiator, "eui") && !strings.HasPrefix(initiator, "naa") {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("initiatorname"), initiator, "must be valid format starting with iqn, eui, or naa"))
                }
                if strings.HasPrefix(initiator, "iqn") && !iscsiInitiatorIqnRegex.MatchString(initiator) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("initiatorname"), initiator, "must be valid format"))
                } else if strings.HasPrefix(initiator, "eui") && !iscsiInitiatorEuiRegex.MatchString(initiator) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("initiatorname"), initiator, "must be valid format"))
                } else if strings.HasPrefix(initiator, "naa") && !iscsiInitiatorNaaRegex.MatchString(initiator) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("initiatorname"), initiator, "must be valid format"))
                }
        }
        return allErrs
}

func validateISCSIPersistentVolumeSource(iscsi *core.ISCSIPersistentVolumeSource, pvName string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(iscsi.TargetPortal) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("targetPortal"), ""))
        }
        if iscsi.InitiatorName != nil && len(pvName+":"+iscsi.TargetPortal) > 64 {
                tooLongErr := "Total length of <volume name>:<iscsi.targetPortal> must be under 64 characters if iscsi.initiatorName is specified."
                allErrs = append(allErrs, field.Invalid(fldPath.Child("targetportal"), iscsi.TargetPortal, tooLongErr))
        }
        if len(iscsi.IQN) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("iqn"), ""))
        } else {
                if !strings.HasPrefix(iscsi.IQN, "iqn") && !strings.HasPrefix(iscsi.IQN, "eui") && !strings.HasPrefix(iscsi.IQN, "naa") {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("iqn"), iscsi.IQN, "must be valid format"))
                } else if strings.HasPrefix(iscsi.IQN, "iqn") && !iscsiInitiatorIqnRegex.MatchString(iscsi.IQN) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("iqn"), iscsi.IQN, "must be valid format"))
                } else if strings.HasPrefix(iscsi.IQN, "eui") && !iscsiInitiatorEuiRegex.MatchString(iscsi.IQN) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("iqn"), iscsi.IQN, "must be valid format"))
                } else if strings.HasPrefix(iscsi.IQN, "naa") && !iscsiInitiatorNaaRegex.MatchString(iscsi.IQN) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("iqn"), iscsi.IQN, "must be valid format"))
                }
        }
        if iscsi.Lun < 0 || iscsi.Lun > 255 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("lun"), iscsi.Lun, validation.InclusiveRangeError(0, 255)))
        }
        if (iscsi.DiscoveryCHAPAuth || iscsi.SessionCHAPAuth) && iscsi.SecretRef == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("secretRef"), ""))
        }
        if iscsi.SecretRef != nil {
                if len(iscsi.SecretRef.Name) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("secretRef", "name"), ""))
                }
        }
        if iscsi.InitiatorName != nil {
                initiator := *iscsi.InitiatorName
                if !strings.HasPrefix(initiator, "iqn") && !strings.HasPrefix(initiator, "eui") && !strings.HasPrefix(initiator, "naa") {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("initiatorname"), initiator, "must be valid format"))
                }
                if strings.HasPrefix(initiator, "iqn") && !iscsiInitiatorIqnRegex.MatchString(initiator) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("initiatorname"), initiator, "must be valid format"))
                } else if strings.HasPrefix(initiator, "eui") && !iscsiInitiatorEuiRegex.MatchString(initiator) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("initiatorname"), initiator, "must be valid format"))
                } else if strings.HasPrefix(initiator, "naa") && !iscsiInitiatorNaaRegex.MatchString(initiator) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("initiatorname"), initiator, "must be valid format"))
                }
        }
        return allErrs
}

func validateFCVolumeSource(fc *core.FCVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(fc.TargetWWNs) < 1 && len(fc.WWIDs) < 1 {
                allErrs = append(allErrs, field.Required(fldPath.Child("targetWWNs"), "must specify either targetWWNs or wwids, but not both"))
        }

        if len(fc.TargetWWNs) != 0 && len(fc.WWIDs) != 0 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("targetWWNs"), fc.TargetWWNs, "targetWWNs and wwids can not be specified simultaneously"))
        }

        if len(fc.TargetWWNs) != 0 {
                if fc.Lun == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("lun"), "lun is required if targetWWNs is specified"))
                } else {
                        if *fc.Lun < 0 || *fc.Lun > 255 {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("lun"), fc.Lun, validation.InclusiveRangeError(0, 255)))
                        }
                }
        }
        return allErrs
}

func validateGCEPersistentDiskVolumeSource(pd *core.GCEPersistentDiskVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(pd.PDName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("pdName"), ""))
        }
        if pd.Partition < 0 || pd.Partition > 255 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("partition"), pd.Partition, pdPartitionErrorMsg))
        }
        return allErrs
}

func validateAWSElasticBlockStoreVolumeSource(PD *core.AWSElasticBlockStoreVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(PD.VolumeID) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeID"), ""))
        }
        if PD.Partition < 0 || PD.Partition > 255 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("partition"), PD.Partition, pdPartitionErrorMsg))
        }
        return allErrs
}

func validateSecretVolumeSource(secretSource *core.SecretVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(secretSource.SecretName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("secretName"), ""))
        }

        secretMode := secretSource.DefaultMode
        if secretMode != nil && (*secretMode > 0777 || *secretMode < 0) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("defaultMode"), *secretMode, fileModeErrorMsg))
        }

        itemsPath := fldPath.Child("items")
        for i, kp := range secretSource.Items {
                itemPath := itemsPath.Index(i)
                allErrs = append(allErrs, validateKeyToPath(&kp, itemPath)...)
        }
        return allErrs
}

func validateConfigMapVolumeSource(configMapSource *core.ConfigMapVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(configMapSource.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        }

        configMapMode := configMapSource.DefaultMode
        if configMapMode != nil && (*configMapMode > 0777 || *configMapMode < 0) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("defaultMode"), *configMapMode, fileModeErrorMsg))
        }

        itemsPath := fldPath.Child("items")
        for i, kp := range configMapSource.Items {
                itemPath := itemsPath.Index(i)
                allErrs = append(allErrs, validateKeyToPath(&kp, itemPath)...)
        }
        return allErrs
}

func validateKeyToPath(kp *core.KeyToPath, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(kp.Key) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("key"), ""))
        }
        if len(kp.Path) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
        }
        allErrs = append(allErrs, ValidateLocalNonReservedPath(kp.Path, fldPath.Child("path"))...)
        if kp.Mode != nil && (*kp.Mode > 0777 || *kp.Mode < 0) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("mode"), *kp.Mode, fileModeErrorMsg))
        }

        return allErrs
}

func validatePersistentClaimVolumeSource(claim *core.PersistentVolumeClaimVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(claim.ClaimName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("claimName"), ""))
        }
        return allErrs
}

func validateNFSVolumeSource(nfs *core.NFSVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(nfs.Server) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("server"), ""))
        }
        if len(nfs.Path) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
        }
        if !path.IsAbs(nfs.Path) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("path"), nfs.Path, "must be an absolute path"))
        }
        return allErrs
}

func validateQuobyteVolumeSource(quobyte *core.QuobyteVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(quobyte.Registry) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("registry"), "must be a host:port pair or multiple pairs separated by commas"))
        } else if len(quobyte.Tenant) >= 65 {
                allErrs = append(allErrs, field.Required(fldPath.Child("tenant"), "must be a UUID and may not exceed a length of 64 characters"))
        } else {
                for _, hostPortPair := range strings.Split(quobyte.Registry, ",") {
                        if _, _, err := net.SplitHostPort(hostPortPair); err != nil {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("registry"), quobyte.Registry, "must be a host:port pair or multiple pairs separated by commas"))
                        }
                }
        }

        if len(quobyte.Volume) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volume"), ""))
        }
        return allErrs
}

func validateGlusterfsVolumeSource(glusterfs *core.GlusterfsVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(glusterfs.EndpointsName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("endpoints"), ""))
        }
        if len(glusterfs.Path) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
        }
        return allErrs
}
func validateGlusterfsPersistentVolumeSource(glusterfs *core.GlusterfsPersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(glusterfs.EndpointsName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("endpoints"), ""))
        }
        if len(glusterfs.Path) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
        }
        if glusterfs.EndpointsNamespace != nil {
                endpointNs := glusterfs.EndpointsNamespace
                if *endpointNs == "" {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("endpointsNamespace"), *endpointNs, "if the endpointnamespace is set, it must be a valid namespace name"))
                } else {
                        for _, msg := range ValidateNamespaceName(*endpointNs, false) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("endpointsNamespace"), *endpointNs, msg))
                        }
                }
        }
        return allErrs
}

func validateFlockerVolumeSource(flocker *core.FlockerVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(flocker.DatasetName) == 0 && len(flocker.DatasetUUID) == 0 {
                // TODO: consider adding a RequiredOneOf() error for this and similar cases
                allErrs = append(allErrs, field.Required(fldPath, "one of datasetName and datasetUUID is required"))
        }
        if len(flocker.DatasetName) != 0 && len(flocker.DatasetUUID) != 0 {
                allErrs = append(allErrs, field.Invalid(fldPath, "resource", "datasetName and datasetUUID can not be specified simultaneously"))
        }
        if strings.Contains(flocker.DatasetName, "/") {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("datasetName"), flocker.DatasetName, "must not contain '/'"))
        }
        return allErrs
}

var validVolumeDownwardAPIFieldPathExpressions = sets.New(
        "metadata.name",
        "metadata.namespace",
        "metadata.labels",
        "metadata.annotations",
        "metadata.uid")

func validateDownwardAPIVolumeFile(file *core.DownwardAPIVolumeFile, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(file.Path) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
        }
        allErrs = append(allErrs, ValidateLocalNonReservedPath(file.Path, fldPath.Child("path"))...)
        if file.FieldRef != nil {
                allErrs = append(allErrs, validateObjectFieldSelector(file.FieldRef, &validVolumeDownwardAPIFieldPathExpressions, fldPath.Child("fieldRef"))...)
                if file.ResourceFieldRef != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath, "resource", "fieldRef and resourceFieldRef can not be specified simultaneously"))
                }
        } else if file.ResourceFieldRef != nil {
                localValidContainerResourceFieldPathPrefixes := validContainerResourceFieldPathPrefixesWithDownwardAPIHugePages
                allErrs = append(allErrs, validateContainerResourceFieldSelector(file.ResourceFieldRef, &validContainerResourceFieldPathExpressions, &localValidContainerResourceFieldPathPrefixes, fldPath.Child("resourceFieldRef"), true)...)
        } else {
                allErrs = append(allErrs, field.Required(fldPath, "one of fieldRef and resourceFieldRef is required"))
        }
        if file.Mode != nil && (*file.Mode > 0777 || *file.Mode < 0) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("mode"), *file.Mode, fileModeErrorMsg))
        }

        return allErrs
}

func validateDownwardAPIVolumeSource(downwardAPIVolume *core.DownwardAPIVolumeSource, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        downwardAPIMode := downwardAPIVolume.DefaultMode
        if downwardAPIMode != nil && (*downwardAPIMode > 0777 || *downwardAPIMode < 0) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("defaultMode"), *downwardAPIMode, fileModeErrorMsg))
        }

        for _, file := range downwardAPIVolume.Items {
                allErrs = append(allErrs, validateDownwardAPIVolumeFile(&file, fldPath, opts)...)
        }
        return allErrs
}

func validateProjectionSources(projection *core.ProjectedVolumeSource, projectionMode *int32, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        allPaths := sets.Set[string]{}

        for i, source := range projection.Sources {
                numSources := 0
                srcPath := fldPath.Child("sources").Index(i)
                if projPath := srcPath.Child("secret"); source.Secret != nil {
                        numSources++
                        if len(source.Secret.Name) == 0 {
                                allErrs = append(allErrs, field.Required(projPath.Child("name"), ""))
                        }
                        itemsPath := projPath.Child("items")
                        for i, kp := range source.Secret.Items {
                                itemPath := itemsPath.Index(i)
                                allErrs = append(allErrs, validateKeyToPath(&kp, itemPath)...)
                                if len(kp.Path) > 0 {
                                        curPath := kp.Path
                                        if !allPaths.Has(curPath) {
                                                allPaths.Insert(curPath)
                                        } else {
                                                allErrs = append(allErrs, field.Invalid(fldPath, source.Secret.Name, "conflicting duplicate paths"))
                                        }
                                }
                        }
                }
                if projPath := srcPath.Child("configMap"); source.ConfigMap != nil {
                        numSources++
                        if len(source.ConfigMap.Name) == 0 {
                                allErrs = append(allErrs, field.Required(projPath.Child("name"), ""))
                        }
                        itemsPath := projPath.Child("items")
                        for i, kp := range source.ConfigMap.Items {
                                itemPath := itemsPath.Index(i)
                                allErrs = append(allErrs, validateKeyToPath(&kp, itemPath)...)
                                if len(kp.Path) > 0 {
                                        curPath := kp.Path
                                        if !allPaths.Has(curPath) {
                                                allPaths.Insert(curPath)
                                        } else {
                                                allErrs = append(allErrs, field.Invalid(fldPath, source.ConfigMap.Name, "conflicting duplicate paths"))
                                        }
                                }
                        }
                }
                if projPath := srcPath.Child("downwardAPI"); source.DownwardAPI != nil {
                        numSources++
                        for _, file := range source.DownwardAPI.Items {
                                allErrs = append(allErrs, validateDownwardAPIVolumeFile(&file, projPath, opts)...)
                                if len(file.Path) > 0 {
                                        curPath := file.Path
                                        if !allPaths.Has(curPath) {
                                                allPaths.Insert(curPath)
                                        } else {
                                                allErrs = append(allErrs, field.Invalid(fldPath, curPath, "conflicting duplicate paths"))
                                        }
                                }
                        }
                }
                if projPath := srcPath.Child("serviceAccountToken"); source.ServiceAccountToken != nil {
                        numSources++
                        if source.ServiceAccountToken.ExpirationSeconds < 10*60 {
                                allErrs = append(allErrs, field.Invalid(projPath.Child("expirationSeconds"), source.ServiceAccountToken.ExpirationSeconds, "may not specify a duration less than 10 minutes"))
                        }
                        if source.ServiceAccountToken.ExpirationSeconds > 1<<32 {
                                allErrs = append(allErrs, field.Invalid(projPath.Child("expirationSeconds"), source.ServiceAccountToken.ExpirationSeconds, "may not specify a duration larger than 2^32 seconds"))
                        }
                        if source.ServiceAccountToken.Path == "" {
                                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
                        } else if !opts.AllowNonLocalProjectedTokenPath {
                                allErrs = append(allErrs, ValidateLocalNonReservedPath(source.ServiceAccountToken.Path, fldPath.Child("path"))...)
                        }
                }
                if projPath := srcPath.Child("clusterTrustBundle"); source.ClusterTrustBundle != nil {
                        numSources++

                        usingName := source.ClusterTrustBundle.Name != nil
                        usingSignerName := source.ClusterTrustBundle.SignerName != nil

                        switch {
                        case usingName && usingSignerName:
                                allErrs = append(allErrs, field.Invalid(projPath, source.ClusterTrustBundle, "only one of name and signerName may be used"))
                        case usingName:
                                if *source.ClusterTrustBundle.Name == "" {
                                        allErrs = append(allErrs, field.Required(projPath.Child("name"), "must be a valid object name"))
                                }

                                name := *source.ClusterTrustBundle.Name
                                if signerName, ok := extractSignerNameFromClusterTrustBundleName(name); ok {
                                        validationFunc := ValidateClusterTrustBundleName(signerName)
                                        errMsgs := validationFunc(name, false)
                                        for _, msg := range errMsgs {
                                                allErrs = append(allErrs, field.Invalid(projPath.Child("name"), name, fmt.Sprintf("not a valid clustertrustbundlename: %v", msg)))
                                        }
                                } else {
                                        validationFunc := ValidateClusterTrustBundleName("")
                                        errMsgs := validationFunc(name, false)
                                        for _, msg := range errMsgs {
                                                allErrs = append(allErrs, field.Invalid(projPath.Child("name"), name, fmt.Sprintf("not a valid clustertrustbundlename: %v", msg)))
                                        }
                                }

                                if source.ClusterTrustBundle.LabelSelector != nil {
                                        allErrs = append(allErrs, field.Invalid(projPath.Child("labelSelector"), source.ClusterTrustBundle.LabelSelector, "labelSelector must be unset if name is specified"))
                                }
                        case usingSignerName:
                                if *source.ClusterTrustBundle.SignerName == "" {
                                        allErrs = append(allErrs, field.Required(projPath.Child("signerName"), "must be a valid signer name"))
                                }

                                allErrs = append(allErrs, ValidateSignerName(projPath.Child("signerName"), *source.ClusterTrustBundle.SignerName)...)

                                labelSelectorErrs := unversionedvalidation.ValidateLabelSelector(
                                        source.ClusterTrustBundle.LabelSelector,
                                        unversionedvalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: false},
                                        projPath.Child("labelSelector"),
                                )
                                allErrs = append(allErrs, labelSelectorErrs...)

                        default:
                                allErrs = append(allErrs, field.Required(projPath, "either name or signerName must be specified"))
                        }

                        if source.ClusterTrustBundle.Path == "" {
                                allErrs = append(allErrs, field.Required(projPath.Child("path"), ""))
                        }

                        allErrs = append(allErrs, ValidateLocalNonReservedPath(source.ClusterTrustBundle.Path, projPath.Child("path"))...)

                        curPath := source.ClusterTrustBundle.Path
                        if !allPaths.Has(curPath) {
                                allPaths.Insert(curPath)
                        } else {
                                allErrs = append(allErrs, field.Invalid(fldPath, curPath, "conflicting duplicate paths"))
                        }
                }
                if projPath := srcPath.Child("podCertificate"); source.PodCertificate != nil {
                        numSources++

                        allErrs = append(allErrs, ValidateSignerName(projPath.Child("signerName"), source.PodCertificate.SignerName)...)

                        switch source.PodCertificate.KeyType {
                        case "RSA3072", "RSA4096", "ECDSAP256", "ECDSAP384", "ECDSAP521", "ED25519":
                                // ok
                        default:
                                allErrs = append(allErrs, field.NotSupported(projPath.Child("keyType"), source.PodCertificate.KeyType, []string{"RSA3072", "RSA4096", "ECDSAP256", "ECDSAP384", "ECDSAP521", "ED25519"}))
                        }

                        if source.PodCertificate.MaxExpirationSeconds != nil {
                                if *source.PodCertificate.MaxExpirationSeconds < 3600 {
                                        allErrs = append(allErrs, field.Invalid(projPath.Child("maxExpirationSeconds"), *source.PodCertificate.MaxExpirationSeconds, "if provided, maxExpirationSeconds must be >= 3600"))
                                }
                                maxMaxExpirationSeconds := certificates.MaxMaxExpirationSeconds
                                if IsKubernetesSignerName(source.PodCertificate.SignerName) {
                                        maxMaxExpirationSeconds = certificates.KubernetesMaxMaxExpirationSeconds
                                }
                                if *source.PodCertificate.MaxExpirationSeconds > int32(maxMaxExpirationSeconds) {
                                        allErrs = append(allErrs, field.Invalid(projPath.Child("maxExpirationSeconds"), *source.PodCertificate.MaxExpirationSeconds, fmt.Sprintf("if provided, maxExpirationSeconds must be <= %d", maxMaxExpirationSeconds)))
                                }
                        }

                        numPaths := 0
                        if len(source.PodCertificate.CredentialBundlePath) != 0 {
                                numPaths++
                                // Credential bundle path must not be weird.
                                allErrs = append(allErrs, ValidateLocalNonReservedPath(source.PodCertificate.CredentialBundlePath, projPath.Child("credentialBundlePath"))...)
                                // Credential bundle path must not collide with a path from another source.
                                if !allPaths.Has(source.PodCertificate.CredentialBundlePath) {
                                        allPaths.Insert(source.PodCertificate.CredentialBundlePath)
                                } else {
                                        allErrs = append(allErrs, field.Invalid(fldPath, source.PodCertificate.CredentialBundlePath, "conflicting duplicate paths"))
                                }
                        }

                        if len(source.PodCertificate.KeyPath) != 0 {
                                numPaths++
                                allErrs = append(allErrs, ValidateLocalNonReservedPath(source.PodCertificate.KeyPath, projPath.Child("keyPath"))...)
                                if !allPaths.Has(source.PodCertificate.KeyPath) {
                                        allPaths.Insert(source.PodCertificate.KeyPath)
                                } else {
                                        allErrs = append(allErrs, field.Invalid(fldPath, source.PodCertificate.KeyPath, "conflicting duplicate paths"))
                                }

                        }

                        if len(source.PodCertificate.CertificateChainPath) != 0 {
                                numPaths++
                                allErrs = append(allErrs, ValidateLocalNonReservedPath(source.PodCertificate.CertificateChainPath, projPath.Child("certificateChainPath"))...)
                                if !allPaths.Has(source.PodCertificate.CertificateChainPath) {
                                        allPaths.Insert(source.PodCertificate.CertificateChainPath)
                                } else {
                                        allErrs = append(allErrs, field.Invalid(fldPath, source.PodCertificate.CertificateChainPath, "conflicting duplicate paths"))
                                }
                        }

                        if numPaths == 0 {
                                allErrs = append(allErrs, field.Required(projPath, "specify at least one of credentialBundlePath, keyPath, and certificateChainPath"))
                        }
                }
                if numSources > 1 {
                        allErrs = append(allErrs, field.Forbidden(srcPath, "may not specify more than 1 volume type per source"))
                }
        }
        return allErrs
}

func validateProjectedVolumeSource(projection *core.ProjectedVolumeSource, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        projectionMode := projection.DefaultMode
        if projectionMode != nil && (*projectionMode > 0777 || *projectionMode < 0) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("defaultMode"), *projectionMode, fileModeErrorMsg))
        }

        allErrs = append(allErrs, validateProjectionSources(projection, projectionMode, fldPath, opts)...)
        return allErrs
}

var supportedHostPathTypes = sets.New(
        core.HostPathUnset,
        core.HostPathDirectoryOrCreate,
        core.HostPathDirectory,
        core.HostPathFileOrCreate,
        core.HostPathFile,
        core.HostPathSocket,
        core.HostPathCharDev,
        core.HostPathBlockDev)

func validateHostPathType(hostPathType *core.HostPathType, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if hostPathType != nil && !supportedHostPathTypes.Has(*hostPathType) {
                allErrs = append(allErrs, field.NotSupported(fldPath, hostPathType, sets.List(supportedHostPathTypes)))
        }

        return allErrs
}

// This validate will make sure targetPath:
// 1. is not abs path
// 2. does not have any element which is ".."
func validateLocalDescendingPath(targetPath string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if path.IsAbs(targetPath) {
                allErrs = append(allErrs, field.Invalid(fldPath, targetPath, "must be a relative path"))
        }

        allErrs = append(allErrs, validatePathNoBacksteps(targetPath, fldPath)...)

        return allErrs
}

// validatePathNoBacksteps makes sure the targetPath does not have any `..` path elements when split
//
// This assumes the OS of the apiserver and the nodes are the same. The same check should be done
// on the node to ensure there are no backsteps.
func validatePathNoBacksteps(targetPath string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        parts := strings.Split(filepath.ToSlash(targetPath), "/")
        for _, item := range parts {
                if item == ".." {
                        allErrs = append(allErrs, field.Invalid(fldPath, targetPath, "must not contain '..'"))
                        break // even for `../../..`, one error is sufficient to make the point
                }
        }
        return allErrs
}

// validateMountPropagation verifies that MountPropagation field is valid and
// allowed for given container.
func validateMountPropagation(mountPropagation *core.MountPropagationMode, container *core.Container, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if mountPropagation == nil {
                return allErrs
        }

        supportedMountPropagations := sets.New(
                core.MountPropagationBidirectional,
                core.MountPropagationHostToContainer,
                core.MountPropagationNone)

        if !supportedMountPropagations.Has(*mountPropagation) {
                allErrs = append(allErrs, field.NotSupported(fldPath, *mountPropagation, sets.List(supportedMountPropagations)))
        }

        if container == nil {
                // The container is not available yet.
                // Stop validation now, Pod validation will refuse final
                // Pods with Bidirectional propagation in non-privileged containers.
                return allErrs
        }

        privileged := container.SecurityContext != nil && container.SecurityContext.Privileged != nil && *container.SecurityContext.Privileged
        if *mountPropagation == core.MountPropagationBidirectional && !privileged {
                allErrs = append(allErrs, field.Forbidden(fldPath, "Bidirectional mount propagation is available only to privileged containers"))
        }
        return allErrs
}

// validateMountRecursiveReadOnly validates RecursiveReadOnly mounts.
func validateMountRecursiveReadOnly(mount core.VolumeMount, fldPath *field.Path) field.ErrorList {
        if mount.RecursiveReadOnly == nil {
                return nil
        }
        allErrs := field.ErrorList{}
        switch *mount.RecursiveReadOnly {
        case core.RecursiveReadOnlyDisabled:
                // NOP
        case core.RecursiveReadOnlyEnabled, core.RecursiveReadOnlyIfPossible:
                if !mount.ReadOnly {
                        allErrs = append(allErrs, field.Forbidden(fldPath, "may only be specified when readOnly is true"))
                }
                if mount.MountPropagation != nil && *mount.MountPropagation != core.MountPropagationNone {
                        allErrs = append(allErrs, field.Forbidden(fldPath, "may only be specified when mountPropagation is None or not specified"))
                }
        default:
                supportedRRO := sets.New(
                        core.RecursiveReadOnlyDisabled,
                        core.RecursiveReadOnlyIfPossible,
                        core.RecursiveReadOnlyEnabled)
                allErrs = append(allErrs, field.NotSupported(fldPath, *mount.RecursiveReadOnly, sets.List(supportedRRO)))
        }
        return allErrs
}

// ValidateLocalNonReservedPath makes sure targetPath:
// 1. is not abs path
// 2. does not contain any '..' elements
// 3. does not start with '..'
func ValidateLocalNonReservedPath(targetPath string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, validateLocalDescendingPath(targetPath, fldPath)...)
        // Don't report this error if the check for .. elements already caught it.
        if strings.HasPrefix(targetPath, "..") && !strings.HasPrefix(targetPath, "../") {
                allErrs = append(allErrs, field.Invalid(fldPath, targetPath, "must not start with '..'"))
        }
        return allErrs
}

func validateRBDVolumeSource(rbd *core.RBDVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(rbd.CephMonitors) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("monitors"), ""))
        }
        if len(rbd.RBDImage) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("image"), ""))
        }
        return allErrs
}

func validateRBDPersistentVolumeSource(rbd *core.RBDPersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(rbd.CephMonitors) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("monitors"), ""))
        }
        if len(rbd.RBDImage) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("image"), ""))
        }
        return allErrs
}

func validateCinderVolumeSource(cd *core.CinderVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(cd.VolumeID) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeID"), ""))
        }
        if cd.SecretRef != nil {
                if len(cd.SecretRef.Name) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("secretRef", "name"), ""))
                }
        }
        return allErrs
}

func validateCinderPersistentVolumeSource(cd *core.CinderPersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(cd.VolumeID) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeID"), ""))
        }
        if cd.SecretRef != nil {
                if len(cd.SecretRef.Name) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("secretRef", "name"), ""))
                }
                if len(cd.SecretRef.Namespace) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("secretRef", "namespace"), ""))
                }
        }
        return allErrs
}

func validateCephFSVolumeSource(cephfs *core.CephFSVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(cephfs.Monitors) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("monitors"), ""))
        }
        return allErrs
}

func validateCephFSPersistentVolumeSource(cephfs *core.CephFSPersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(cephfs.Monitors) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("monitors"), ""))
        }
        return allErrs
}

func validateFlexVolumeSource(fv *core.FlexVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(fv.Driver) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("driver"), ""))
        }

        // Make sure user-specified options don't use kubernetes namespaces
        for k := range fv.Options {
                namespace := k
                if parts := strings.SplitN(k, "/", 2); len(parts) == 2 {
                        namespace = parts[0]
                }
                normalized := "." + strings.ToLower(namespace)
                if strings.HasSuffix(normalized, ".kubernetes.io") || strings.HasSuffix(normalized, ".k8s.io") {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("options").Key(k), k, "kubernetes.io and k8s.io namespaces are reserved"))
                }
        }

        return allErrs
}

func validateFlexPersistentVolumeSource(fv *core.FlexPersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(fv.Driver) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("driver"), ""))
        }

        // Make sure user-specified options don't use kubernetes namespaces
        for k := range fv.Options {
                namespace := k
                if parts := strings.SplitN(k, "/", 2); len(parts) == 2 {
                        namespace = parts[0]
                }
                normalized := "." + strings.ToLower(namespace)
                if strings.HasSuffix(normalized, ".kubernetes.io") || strings.HasSuffix(normalized, ".k8s.io") {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("options").Key(k), k, "kubernetes.io and k8s.io namespaces are reserved"))
                }
        }

        return allErrs
}

func validateAzureFile(azure *core.AzureFileVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if azure.SecretName == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("secretName"), ""))
        }
        if azure.ShareName == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("shareName"), ""))
        }
        return allErrs
}

func validateAzureFilePV(azure *core.AzureFilePersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if azure.SecretName == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("secretName"), ""))
        }
        if azure.ShareName == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("shareName"), ""))
        }
        if azure.SecretNamespace != nil {
                if len(*azure.SecretNamespace) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("secretNamespace"), ""))
                }
        }
        return allErrs
}

func validateAzureDisk(azure *core.AzureDiskVolumeSource, fldPath *field.Path) field.ErrorList {
        var supportedCachingModes = sets.New(
                core.AzureDataDiskCachingNone,
                core.AzureDataDiskCachingReadOnly,
                core.AzureDataDiskCachingReadWrite)

        var supportedDiskKinds = sets.New(
                core.AzureSharedBlobDisk,
                core.AzureDedicatedBlobDisk,
                core.AzureManagedDisk)

        diskURISupportedManaged := []string{"/subscriptions/{sub-id}/resourcegroups/{group-name}/providers/microsoft.compute/disks/{disk-id}"}
        diskURISupportedblob := []string{"https://{account-name}.blob.core.windows.net/{container-name}/{disk-name}.vhd"}

        allErrs := field.ErrorList{}
        if azure.DiskName == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("diskName"), ""))
        }

        if azure.DataDiskURI == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("diskURI"), ""))
        }

        if azure.CachingMode != nil && !supportedCachingModes.Has(*azure.CachingMode) {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("cachingMode"), *azure.CachingMode, sets.List(supportedCachingModes)))
        }

        if azure.Kind != nil && !supportedDiskKinds.Has(*azure.Kind) {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("kind"), *azure.Kind, sets.List(supportedDiskKinds)))
        }

        // validate that DiskUri is the correct format
        if azure.Kind != nil && *azure.Kind == core.AzureManagedDisk && strings.Index(azure.DataDiskURI, "/subscriptions/") != 0 {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("diskURI"), azure.DataDiskURI, diskURISupportedManaged))
        }

        if azure.Kind != nil && *azure.Kind != core.AzureManagedDisk && strings.Index(azure.DataDiskURI, "https://") != 0 {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("diskURI"), azure.DataDiskURI, diskURISupportedblob))
        }

        return allErrs
}

func validateVsphereVolumeSource(cd *core.VsphereVirtualDiskVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(cd.VolumePath) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumePath"), ""))
        }
        return allErrs
}

func validatePhotonPersistentDiskVolumeSource(cd *core.PhotonPersistentDiskVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(cd.PdID) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("pdID"), ""))
        }
        return allErrs
}

func validatePortworxVolumeSource(pwx *core.PortworxVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(pwx.VolumeID) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeID"), ""))
        }
        return allErrs
}

func validateScaleIOVolumeSource(sio *core.ScaleIOVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if sio.Gateway == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("gateway"), ""))
        }
        if sio.System == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("system"), ""))
        }
        if sio.VolumeName == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeName"), ""))
        }
        return allErrs
}

func validateScaleIOPersistentVolumeSource(sio *core.ScaleIOPersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if sio.Gateway == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("gateway"), ""))
        }
        if sio.System == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("system"), ""))
        }
        if sio.VolumeName == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeName"), ""))
        }
        return allErrs
}

func validateLocalVolumeSource(ls *core.LocalVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if ls.Path == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
                return allErrs
        }

        allErrs = append(allErrs, validatePathNoBacksteps(ls.Path, fldPath.Child("path"))...)
        return allErrs
}

func validateStorageOSVolumeSource(storageos *core.StorageOSVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(storageos.VolumeName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeName"), ""))
        } else {
                allErrs = append(allErrs, ValidateDNS1123Label(storageos.VolumeName, fldPath.Child("volumeName"))...)
        }
        if len(storageos.VolumeNamespace) > 0 {
                allErrs = append(allErrs, ValidateDNS1123Label(storageos.VolumeNamespace, fldPath.Child("volumeNamespace"))...)
        }
        if storageos.SecretRef != nil {
                if len(storageos.SecretRef.Name) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("secretRef", "name"), ""))
                }
        }
        return allErrs
}

func validateStorageOSPersistentVolumeSource(storageos *core.StorageOSPersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(storageos.VolumeName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeName"), ""))
        } else {
                allErrs = append(allErrs, ValidateDNS1123Label(storageos.VolumeName, fldPath.Child("volumeName"))...)
        }
        if len(storageos.VolumeNamespace) > 0 {
                allErrs = append(allErrs, ValidateDNS1123Label(storageos.VolumeNamespace, fldPath.Child("volumeNamespace"))...)
        }
        if storageos.SecretRef != nil {
                if len(storageos.SecretRef.Name) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("secretRef", "name"), ""))
                }
                if len(storageos.SecretRef.Namespace) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("secretRef", "namespace"), ""))
                }
        }
        return allErrs
}

// validatePVSecretReference check whether provided SecretReference object is valid in terms of secret name and namespace.

func validatePVSecretReference(secretRef *core.SecretReference, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        if len(secretRef.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        } else {
                allErrs = append(allErrs, ValidateDNS1123Subdomain(secretRef.Name, fldPath.Child("name"))...)
        }

        if len(secretRef.Namespace) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("namespace"), ""))
        } else {
                allErrs = append(allErrs, ValidateDNS1123Label(secretRef.Namespace, fldPath.Child("namespace"))...)
        }
        return allErrs
}

func ValidateCSIDriverName(driverName string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(driverName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath, ""))
        }

        if len(driverName) > 63 {
                allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, 63))
        }

        for _, msg := range validation.IsDNS1123Subdomain(strings.ToLower(driverName)) {
                allErrs = append(allErrs, field.Invalid(fldPath, driverName, msg)).WithOrigin("format=k8s-long-name")
        }

        return allErrs
}

func validateCSIPersistentVolumeSource(csi *core.CSIPersistentVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        allErrs = append(allErrs, ValidateCSIDriverName(csi.Driver, fldPath.Child("driver"))...)

        if len(csi.VolumeHandle) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeHandle"), ""))
        }
        if csi.ControllerPublishSecretRef != nil {
                allErrs = append(allErrs, validatePVSecretReference(csi.ControllerPublishSecretRef, fldPath.Child("controllerPublishSecretRef"))...)
        }
        if csi.ControllerExpandSecretRef != nil {
                allErrs = append(allErrs, validatePVSecretReference(csi.ControllerExpandSecretRef, fldPath.Child("controllerExpandSecretRef"))...)
        }
        if csi.NodePublishSecretRef != nil {
                allErrs = append(allErrs, validatePVSecretReference(csi.NodePublishSecretRef, fldPath.Child("nodePublishSecretRef"))...)
        }
        if csi.NodeExpandSecretRef != nil {
                allErrs = append(allErrs, validatePVSecretReference(csi.NodeExpandSecretRef, fldPath.Child("nodeExpandSecretRef"))...)
        }
        return allErrs
}

func validateCSIVolumeSource(csi *core.CSIVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateCSIDriverName(csi.Driver, fldPath.Child("driver"))...)

        if csi.NodePublishSecretRef != nil {
                if len(csi.NodePublishSecretRef.Name) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("nodePublishSecretRef", "name"), ""))
                } else {
                        for _, msg := range ValidateSecretName(csi.NodePublishSecretRef.Name, false) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), csi.NodePublishSecretRef.Name, msg))
                        }
                }
        }

        return allErrs
}

func validateEphemeralVolumeSource(ephemeral *core.EphemeralVolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if ephemeral.VolumeClaimTemplate == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeClaimTemplate"), ""))
        } else {
                opts := ValidationOptionsForPersistentVolumeClaimTemplate(ephemeral.VolumeClaimTemplate, nil)
                allErrs = append(allErrs, ValidatePersistentVolumeClaimTemplate(ephemeral.VolumeClaimTemplate, fldPath.Child("volumeClaimTemplate"), opts)...)
        }
        return allErrs
}

// ValidatePersistentVolumeClaimTemplate verifies that the embedded object meta and spec are valid.
// Checking of the object data is very minimal because only labels and annotations are used.
func ValidatePersistentVolumeClaimTemplate(claimTemplate *core.PersistentVolumeClaimTemplate, fldPath *field.Path, opts PersistentVolumeClaimSpecValidationOptions) field.ErrorList {
        allErrs := ValidateTemplateObjectMeta(&claimTemplate.ObjectMeta, fldPath.Child("metadata"))
        allErrs = append(allErrs, ValidatePersistentVolumeClaimSpec(&claimTemplate.Spec, fldPath.Child("spec"), opts)...)
        return allErrs
}

func ValidateTemplateObjectMeta(objMeta *metav1.ObjectMeta, fldPath *field.Path) field.ErrorList {
        allErrs := apimachineryvalidation.ValidateAnnotations(objMeta.Annotations, fldPath.Child("annotations"))
        allErrs = append(allErrs, unversionedvalidation.ValidateLabels(objMeta.Labels, fldPath.Child("labels"))...)
        // All other fields are not supported and thus must not be set
        // to avoid confusion.  We could reject individual fields,
        // but then adding a new one to ObjectMeta wouldn't be checked
        // unless this code gets updated. Instead, we ensure that
        // only allowed fields are set via reflection.
        allErrs = append(allErrs, validateFieldAllowList(*objMeta, allowedTemplateObjectMetaFields, "cannot be set", fldPath)...)
        return allErrs
}

var allowedTemplateObjectMetaFields = map[string]bool{
        "Annotations": true,
        "Labels":      true,
}

// PersistentVolumeSpecValidationOptions contains the different settings for PeristentVolume validation
type PersistentVolumeSpecValidationOptions struct {
        // Allow users to modify the class of volume attributes
        EnableVolumeAttributesClass bool
        // Allow invalid label-value in RequiredNodeSelector
        AllowInvalidLabelValueInRequiredNodeAffinity bool
}

// ValidatePersistentVolumeName checks that a name is appropriate for a
// PersistentVolumeName object.
var ValidatePersistentVolumeName = apimachineryvalidation.NameIsDNSSubdomain

var supportedAccessModes = sets.New(
        core.ReadWriteOnce,
        core.ReadOnlyMany,
        core.ReadWriteMany,
        core.ReadWriteOncePod)

var supportedReclaimPolicy = sets.New(
        core.PersistentVolumeReclaimDelete,
        core.PersistentVolumeReclaimRecycle,
        core.PersistentVolumeReclaimRetain)

var supportedVolumeModes = sets.New(core.PersistentVolumeBlock, core.PersistentVolumeFilesystem)

func ValidationOptionsForPersistentVolume(pv, oldPv *core.PersistentVolume) PersistentVolumeSpecValidationOptions {
        opts := PersistentVolumeSpecValidationOptions{
                EnableVolumeAttributesClass:                  utilfeature.DefaultMutableFeatureGate.Enabled(features.VolumeAttributesClass),
                AllowInvalidLabelValueInRequiredNodeAffinity: false,
        }
        if oldPv != nil && oldPv.Spec.VolumeAttributesClassName != nil {
                opts.EnableVolumeAttributesClass = true
        }
        if oldPv != nil && oldPv.Spec.NodeAffinity != nil &&
                oldPv.Spec.NodeAffinity.Required != nil {
                terms := oldPv.Spec.NodeAffinity.Required.NodeSelectorTerms
                opts.AllowInvalidLabelValueInRequiredNodeAffinity = helper.HasInvalidLabelValueInNodeSelectorTerms(terms)
        }
        return opts
}

func ValidatePersistentVolumeSpec(pvSpec *core.PersistentVolumeSpec, pvName string, validateInlinePersistentVolumeSpec bool, fldPath *field.Path, opts PersistentVolumeSpecValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if validateInlinePersistentVolumeSpec {
                if pvSpec.ClaimRef != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("claimRef"), "may not be specified in the context of inline volumes"))
                }
                if len(pvSpec.Capacity) != 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("capacity"), "may not be specified in the context of inline volumes"))
                }
                if pvSpec.CSI == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("csi"), "has to be specified in the context of inline volumes"))
                }
        }

        if len(pvSpec.AccessModes) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("accessModes"), ""))
        }

        foundReadWriteOncePod, foundNonReadWriteOncePod := false, false
        for _, mode := range pvSpec.AccessModes {
                if !supportedAccessModes.Has(mode) {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("accessModes"), mode, sets.List(supportedAccessModes)))
                }

                if mode == core.ReadWriteOncePod {
                        foundReadWriteOncePod = true
                } else if supportedAccessModes.Has(mode) {
                        foundNonReadWriteOncePod = true
                }
        }
        if foundReadWriteOncePod && foundNonReadWriteOncePod {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("accessModes"), "may not use ReadWriteOncePod with other access modes"))
        }

        if !validateInlinePersistentVolumeSpec {
                if len(pvSpec.Capacity) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("capacity"), ""))
                }

                if _, ok := pvSpec.Capacity[core.ResourceStorage]; !ok || len(pvSpec.Capacity) > 1 {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("capacity"), pvSpec.Capacity, []core.ResourceName{core.ResourceStorage}))
                }
                capPath := fldPath.Child("capacity")
                for r, qty := range pvSpec.Capacity {
                        allErrs = append(allErrs, validateBasicResource(qty, capPath.Key(string(r)))...)
                        allErrs = append(allErrs, ValidatePositiveQuantityValue(qty, capPath.Key(string(r)))...)
                }
        }

        if len(pvSpec.PersistentVolumeReclaimPolicy) > 0 {
                if validateInlinePersistentVolumeSpec {
                        if pvSpec.PersistentVolumeReclaimPolicy != core.PersistentVolumeReclaimRetain {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("persistentVolumeReclaimPolicy"), "may only be "+string(core.PersistentVolumeReclaimRetain)+" in the context of inline volumes"))
                        }
                } else {
                        if !supportedReclaimPolicy.Has(pvSpec.PersistentVolumeReclaimPolicy) {
                                allErrs = append(allErrs, field.NotSupported(fldPath.Child("persistentVolumeReclaimPolicy"), pvSpec.PersistentVolumeReclaimPolicy, sets.List(supportedReclaimPolicy)))
                        }
                }
        }

        var nodeAffinitySpecified bool
        var errs field.ErrorList
        if pvSpec.NodeAffinity != nil {
                if validateInlinePersistentVolumeSpec {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("nodeAffinity"), "may not be specified in the context of inline volumes"))
                } else {
                        nodeAffinitySpecified, errs = validateVolumeNodeAffinity(pvSpec.NodeAffinity, opts, fldPath.Child("nodeAffinity"))
                        allErrs = append(allErrs, errs...)
                }
        }
        numVolumes := 0
        if pvSpec.HostPath != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostPath"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateHostPathVolumeSource(pvSpec.HostPath, fldPath.Child("hostPath"))...)
                }
        }
        if pvSpec.GCEPersistentDisk != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("gcePersistentDisk"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateGCEPersistentDiskVolumeSource(pvSpec.GCEPersistentDisk, fldPath.Child("persistentDisk"))...)
                }
        }
        if pvSpec.AWSElasticBlockStore != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("awsElasticBlockStore"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateAWSElasticBlockStoreVolumeSource(pvSpec.AWSElasticBlockStore, fldPath.Child("awsElasticBlockStore"))...)
                }
        }
        if pvSpec.Glusterfs != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("glusterfs"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateGlusterfsPersistentVolumeSource(pvSpec.Glusterfs, fldPath.Child("glusterfs"))...)
                }
        }
        if pvSpec.Flocker != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("flocker"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateFlockerVolumeSource(pvSpec.Flocker, fldPath.Child("flocker"))...)
                }
        }
        if pvSpec.NFS != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("nfs"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateNFSVolumeSource(pvSpec.NFS, fldPath.Child("nfs"))...)
                }
        }
        if pvSpec.RBD != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("rbd"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateRBDPersistentVolumeSource(pvSpec.RBD, fldPath.Child("rbd"))...)
                }
        }
        if pvSpec.Quobyte != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("quobyte"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateQuobyteVolumeSource(pvSpec.Quobyte, fldPath.Child("quobyte"))...)
                }
        }
        if pvSpec.CephFS != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("cephFS"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateCephFSPersistentVolumeSource(pvSpec.CephFS, fldPath.Child("cephfs"))...)
                }
        }
        if pvSpec.ISCSI != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("iscsi"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateISCSIPersistentVolumeSource(pvSpec.ISCSI, pvName, fldPath.Child("iscsi"))...)
                }
        }
        if pvSpec.Cinder != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("cinder"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateCinderPersistentVolumeSource(pvSpec.Cinder, fldPath.Child("cinder"))...)
                }
        }
        if pvSpec.FC != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("fc"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateFCVolumeSource(pvSpec.FC, fldPath.Child("fc"))...)
                }
        }
        if pvSpec.FlexVolume != nil {
                numVolumes++
                allErrs = append(allErrs, validateFlexPersistentVolumeSource(pvSpec.FlexVolume, fldPath.Child("flexVolume"))...)
        }
        if pvSpec.AzureFile != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("azureFile"), "may not specify more than 1 volume type"))

                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateAzureFilePV(pvSpec.AzureFile, fldPath.Child("azureFile"))...)
                }
        }

        if pvSpec.VsphereVolume != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("vsphereVolume"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateVsphereVolumeSource(pvSpec.VsphereVolume, fldPath.Child("vsphereVolume"))...)
                }
        }
        if pvSpec.PhotonPersistentDisk != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("photonPersistentDisk"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validatePhotonPersistentDiskVolumeSource(pvSpec.PhotonPersistentDisk, fldPath.Child("photonPersistentDisk"))...)
                }
        }
        if pvSpec.PortworxVolume != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("portworxVolume"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validatePortworxVolumeSource(pvSpec.PortworxVolume, fldPath.Child("portworxVolume"))...)
                }
        }
        if pvSpec.AzureDisk != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("azureDisk"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateAzureDisk(pvSpec.AzureDisk, fldPath.Child("azureDisk"))...)
                }
        }
        if pvSpec.ScaleIO != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("scaleIO"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateScaleIOPersistentVolumeSource(pvSpec.ScaleIO, fldPath.Child("scaleIO"))...)
                }
        }
        if pvSpec.Local != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("local"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateLocalVolumeSource(pvSpec.Local, fldPath.Child("local"))...)
                        // NodeAffinity is required
                        if !nodeAffinitySpecified {
                                allErrs = append(allErrs, field.Required(fldPath.Child("nodeAffinity"), "Local volume requires node affinity"))
                        }
                }
        }
        if pvSpec.StorageOS != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("storageos"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateStorageOSPersistentVolumeSource(pvSpec.StorageOS, fldPath.Child("storageos"))...)
                }
        }

        if pvSpec.CSI != nil {
                if numVolumes > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("csi"), "may not specify more than 1 volume type"))
                } else {
                        numVolumes++
                        allErrs = append(allErrs, validateCSIPersistentVolumeSource(pvSpec.CSI, fldPath.Child("csi"))...)
                }
        }

        if numVolumes == 0 {
                allErrs = append(allErrs, field.Required(fldPath, "must specify a volume type"))
        }

        // do not allow hostPath mounts of '/' to have a 'recycle' reclaim policy
        if pvSpec.HostPath != nil && path.Clean(pvSpec.HostPath.Path) == "/" && pvSpec.PersistentVolumeReclaimPolicy == core.PersistentVolumeReclaimRecycle {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("persistentVolumeReclaimPolicy"), "may not be 'recycle' for a hostPath mount of '/'"))
        }

        if len(pvSpec.StorageClassName) > 0 {
                if validateInlinePersistentVolumeSpec {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("storageClassName"), "may not be specified in the context of inline volumes"))
                } else {
                        for _, msg := range ValidateClassName(pvSpec.StorageClassName, false) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("storageClassName"), pvSpec.StorageClassName, msg))
                        }
                }
        }
        if pvSpec.VolumeMode != nil {
                if validateInlinePersistentVolumeSpec {
                        if *pvSpec.VolumeMode != core.PersistentVolumeFilesystem {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("volumeMode"), "may not specify volumeMode other than "+string(core.PersistentVolumeFilesystem)+" in the context of inline volumes"))
                        }
                } else {
                        if !supportedVolumeModes.Has(*pvSpec.VolumeMode) {
                                allErrs = append(allErrs, field.NotSupported(fldPath.Child("volumeMode"), *pvSpec.VolumeMode, sets.List(supportedVolumeModes)))
                        }
                }
        }
        if pvSpec.VolumeAttributesClassName != nil && opts.EnableVolumeAttributesClass {
                if len(*pvSpec.VolumeAttributesClassName) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("volumeAttributesClassName"), "an empty string is disallowed"))
                } else {
                        for _, msg := range ValidateClassName(*pvSpec.VolumeAttributesClassName, false) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("volumeAttributesClassName"), *pvSpec.VolumeAttributesClassName, msg))
                        }
                }
                if pvSpec.CSI == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("csi"), "has to be specified when using volumeAttributesClassName"))
                }
        }
        return allErrs
}

func ValidatePersistentVolume(pv *core.PersistentVolume, opts PersistentVolumeSpecValidationOptions) field.ErrorList {
        metaPath := field.NewPath("metadata")
        allErrs := ValidateObjectMeta(&pv.ObjectMeta, false, ValidatePersistentVolumeName, metaPath)
        allErrs = append(allErrs, ValidatePersistentVolumeSpec(&pv.Spec, pv.ObjectMeta.Name, false, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidatePersistentVolumeUpdate tests to see if the update is legal for an end user to make.
// newPv is updated with fields that cannot be changed.
func ValidatePersistentVolumeUpdate(newPv, oldPv *core.PersistentVolume, opts PersistentVolumeSpecValidationOptions) field.ErrorList {
        allErrs := ValidatePersistentVolume(newPv, opts)

        // if oldPV does not have ControllerExpandSecretRef then allow it to be set
        if (oldPv.Spec.CSI != nil && oldPv.Spec.CSI.ControllerExpandSecretRef == nil) &&
                (newPv.Spec.CSI != nil && newPv.Spec.CSI.ControllerExpandSecretRef != nil) {
                newPv = newPv.DeepCopy()
                newPv.Spec.CSI.ControllerExpandSecretRef = nil
        }

        // PersistentVolumeSource should be immutable after creation.
        if !apiequality.Semantic.DeepEqual(newPv.Spec.PersistentVolumeSource, oldPv.Spec.PersistentVolumeSource) {
                pvcSourceDiff := diff.Diff(oldPv.Spec.PersistentVolumeSource, newPv.Spec.PersistentVolumeSource)
                allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "persistentvolumesource"), fmt.Sprintf("spec.persistentvolumesource is immutable after creation\n%v", pvcSourceDiff)))
        }
        allErrs = append(allErrs, ValidateImmutableField(newPv.Spec.VolumeMode, oldPv.Spec.VolumeMode, field.NewPath("volumeMode"))...)

        // Allow setting NodeAffinity if oldPv NodeAffinity was not set
        if oldPv.Spec.NodeAffinity != nil {
                allErrs = append(allErrs, validatePvNodeAffinity(newPv.Spec.NodeAffinity, oldPv.Spec.NodeAffinity, field.NewPath("nodeAffinity"))...)
        }

        if !apiequality.Semantic.DeepEqual(oldPv.Spec.VolumeAttributesClassName, newPv.Spec.VolumeAttributesClassName) {
                if !utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "volumeAttributesClassName"), "update is forbidden when the VolumeAttributesClass feature gate is disabled"))
                }
                if opts.EnableVolumeAttributesClass {
                        if oldPv.Spec.VolumeAttributesClassName != nil && newPv.Spec.VolumeAttributesClassName == nil {
                                allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "volumeAttributesClassName"), "update from non-nil value to nil is forbidden"))
                        }
                }
        }

        return allErrs
}

// ValidatePersistentVolumeStatusUpdate tests to see if the status update is legal for an end user to make.
func ValidatePersistentVolumeStatusUpdate(newPv, oldPv *core.PersistentVolume) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newPv.ObjectMeta, &oldPv.ObjectMeta, field.NewPath("metadata"))
        if len(newPv.ResourceVersion) == 0 {
                allErrs = append(allErrs, field.Required(field.NewPath("resourceVersion"), ""))
        }
        return allErrs
}

type PersistentVolumeClaimSpecValidationOptions struct {
        // Allow users to recover from previously failing expansion operation
        EnableRecoverFromExpansionFailure bool
        // Allow to validate the label value of the label selector
        AllowInvalidLabelValueInSelector bool
        // Allow to validate the API group of the data source and data source reference
        AllowInvalidAPIGroupInDataSourceOrRef bool
        // Allow users to modify the class of volume attributes
        EnableVolumeAttributesClass bool
}

func ValidationOptionsForPersistentVolumeClaimCreate() PersistentVolumeClaimSpecValidationOptions {
        return PersistentVolumeClaimSpecValidationOptions{
                EnableRecoverFromExpansionFailure: utilfeature.DefaultFeatureGate.Enabled(features.RecoverVolumeExpansionFailure),
                AllowInvalidLabelValueInSelector:  false,
                EnableVolumeAttributesClass:       utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass),
        }
}

func ValidationOptionsForPersistentVolumeClaim(pvc, oldPvc *core.PersistentVolumeClaim) PersistentVolumeClaimSpecValidationOptions {
        opts := ValidationOptionsForPersistentVolumeClaimCreate()
        if oldPvc == nil {
                // If there's no old PVC, use the options based solely on feature enablement
                return opts
        }

        // If the old object had an invalid API group in the data source or data source reference, continue to allow it in the new object
        opts.AllowInvalidAPIGroupInDataSourceOrRef = allowInvalidAPIGroupInDataSourceOrRef(&oldPvc.Spec)

        if oldPvc.Spec.VolumeAttributesClassName != nil {
                // If the old object had a volume attributes class, continue to validate it in the new object.
                opts.EnableVolumeAttributesClass = true
        }

        labelSelectorValidationOpts := unversionedvalidation.LabelSelectorValidationOptions{
                AllowInvalidLabelValueInSelector: opts.AllowInvalidLabelValueInSelector,
        }
        if len(unversionedvalidation.ValidateLabelSelector(oldPvc.Spec.Selector, labelSelectorValidationOpts, nil)) > 0 {
                // If the old object had an invalid label selector, continue to allow it in the new object
                opts.AllowInvalidLabelValueInSelector = true
        }

        if helper.ClaimContainsAllocatedResources(oldPvc) ||
                helper.ClaimContainsAllocatedResourceStatus(oldPvc) {
                opts.EnableRecoverFromExpansionFailure = true
        }
        return opts
}

func ValidationOptionsForPersistentVolumeClaimTemplate(claimTemplate, oldClaimTemplate *core.PersistentVolumeClaimTemplate) PersistentVolumeClaimSpecValidationOptions {
        opts := PersistentVolumeClaimSpecValidationOptions{
                AllowInvalidLabelValueInSelector: false,
                EnableVolumeAttributesClass:      utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass),
        }
        if oldClaimTemplate == nil {
                // If there's no old PVC template, use the options based solely on feature enablement
                return opts
        }
        labelSelectorValidationOpts := unversionedvalidation.LabelSelectorValidationOptions{
                AllowInvalidLabelValueInSelector: opts.AllowInvalidLabelValueInSelector,
        }
        if len(unversionedvalidation.ValidateLabelSelector(oldClaimTemplate.Spec.Selector, labelSelectorValidationOpts, nil)) > 0 {
                // If the old object had an invalid label selector, continue to allow it in the new object
                opts.AllowInvalidLabelValueInSelector = true
        }
        return opts
}

// allowInvalidAPIGroupInDataSourceOrRef returns true if the spec contains a data source or data source reference with an API group
func allowInvalidAPIGroupInDataSourceOrRef(spec *core.PersistentVolumeClaimSpec) bool {
        if spec.DataSource != nil && spec.DataSource.APIGroup != nil {
                return true
        }
        if spec.DataSourceRef != nil && spec.DataSourceRef.APIGroup != nil {
                return true
        }
        return false
}

// ValidatePersistentVolumeClaim validates a PersistentVolumeClaim
func ValidatePersistentVolumeClaim(pvc *core.PersistentVolumeClaim, opts PersistentVolumeClaimSpecValidationOptions) field.ErrorList {
        allErrs := ValidateObjectMeta(&pvc.ObjectMeta, true, ValidatePersistentVolumeName, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidatePersistentVolumeClaimSpec(&pvc.Spec, field.NewPath("spec"), opts)...)
        return allErrs
}

// validateDataSource validates a DataSource/DataSourceRef in a PersistentVolumeClaimSpec
func validateDataSource(dataSource *core.TypedLocalObjectReference, fldPath *field.Path, allowInvalidAPIGroupInDataSourceOrRef bool) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(dataSource.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        }
        if len(dataSource.Kind) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("kind"), ""))
        }
        apiGroup := ""
        if dataSource.APIGroup != nil {
                apiGroup = *dataSource.APIGroup
        }
        if len(apiGroup) == 0 && dataSource.Kind != "PersistentVolumeClaim" {
                allErrs = append(allErrs, field.Invalid(fldPath, dataSource.Kind, "must be 'PersistentVolumeClaim' when referencing the default apiGroup"))
        }
        if len(apiGroup) > 0 && !allowInvalidAPIGroupInDataSourceOrRef {
                for _, errString := range validation.IsDNS1123Subdomain(apiGroup) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("apiGroup"), apiGroup, errString))
                }
        }

        return allErrs
}

// validateDataSourceRef validates a DataSourceRef in a PersistentVolumeClaimSpec
func validateDataSourceRef(dataSourceRef *core.TypedObjectReference, fldPath *field.Path, allowInvalidAPIGroupInDataSourceOrRef bool) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(dataSourceRef.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        }
        if len(dataSourceRef.Kind) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("kind"), ""))
        }
        apiGroup := ""
        if dataSourceRef.APIGroup != nil {
                apiGroup = *dataSourceRef.APIGroup
        }
        if len(apiGroup) == 0 && dataSourceRef.Kind != "PersistentVolumeClaim" {
                allErrs = append(allErrs, field.Invalid(fldPath, dataSourceRef.Kind, "must be 'PersistentVolumeClaim' when referencing the default apiGroup"))
        }
        if len(apiGroup) > 0 && !allowInvalidAPIGroupInDataSourceOrRef {
                for _, errString := range validation.IsDNS1123Subdomain(apiGroup) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("apiGroup"), apiGroup, errString))
                }
        }

        if dataSourceRef.Namespace != nil && len(*dataSourceRef.Namespace) > 0 {
                for _, msg := range ValidateNameFunc(ValidateNamespaceName)(*dataSourceRef.Namespace, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), *dataSourceRef.Namespace, msg))
                }
        }

        return allErrs
}

// ValidatePersistentVolumeClaimSpec validates a PersistentVolumeClaimSpec
func ValidatePersistentVolumeClaimSpec(spec *core.PersistentVolumeClaimSpec, fldPath *field.Path, opts PersistentVolumeClaimSpecValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(spec.AccessModes) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("accessModes"), "at least 1 access mode is required"))
        }
        if spec.Selector != nil {
                labelSelectorValidationOpts := unversionedvalidation.LabelSelectorValidationOptions{
                        AllowInvalidLabelValueInSelector: opts.AllowInvalidLabelValueInSelector,
                }
                allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(spec.Selector, labelSelectorValidationOpts, fldPath.Child("selector"))...)
        }

        foundReadWriteOncePod, foundNonReadWriteOncePod := false, false
        for _, mode := range spec.AccessModes {
                if !supportedAccessModes.Has(mode) {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("accessModes"), mode, sets.List(supportedAccessModes)))
                }

                if mode == core.ReadWriteOncePod {
                        foundReadWriteOncePod = true
                } else if supportedAccessModes.Has(mode) {
                        foundNonReadWriteOncePod = true
                }
        }
        if foundReadWriteOncePod && foundNonReadWriteOncePod {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("accessModes"), "may not use ReadWriteOncePod with other access modes"))
        }

        storageValue, ok := spec.Resources.Requests[core.ResourceStorage]
        if !ok {
                allErrs = append(allErrs, field.Required(fldPath.Child("resources").Key(string(core.ResourceStorage)), ""))
        } else if errs := ValidatePositiveQuantityValue(storageValue, fldPath.Child("resources").Key(string(core.ResourceStorage))); len(errs) > 0 {
                allErrs = append(allErrs, errs...)
        } else {
                allErrs = append(allErrs, ValidateResourceQuantityValue(core.ResourceStorage, storageValue, fldPath.Child("resources").Key(string(core.ResourceStorage)))...)
        }

        if spec.StorageClassName != nil && len(*spec.StorageClassName) > 0 {
                for _, msg := range ValidateClassName(*spec.StorageClassName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("storageClassName"), *spec.StorageClassName, msg))
                }
        }
        if spec.VolumeMode != nil && !supportedVolumeModes.Has(*spec.VolumeMode) {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("volumeMode"), *spec.VolumeMode, sets.List(supportedVolumeModes)))
        }

        if spec.DataSource != nil {
                allErrs = append(allErrs, validateDataSource(spec.DataSource, fldPath.Child("dataSource"), opts.AllowInvalidAPIGroupInDataSourceOrRef)...)
        }
        if spec.DataSourceRef != nil {
                allErrs = append(allErrs, validateDataSourceRef(spec.DataSourceRef, fldPath.Child("dataSourceRef"), opts.AllowInvalidAPIGroupInDataSourceOrRef)...)
        }
        if spec.DataSourceRef != nil && spec.DataSourceRef.Namespace != nil && len(*spec.DataSourceRef.Namespace) > 0 {
                if spec.DataSource != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath, fldPath.Child("dataSource"),
                                "may not be specified when dataSourceRef.namespace is specified"))
                }
        } else if spec.DataSource != nil && spec.DataSourceRef != nil {
                if !isDataSourceEqualDataSourceRef(spec.DataSource, spec.DataSourceRef) {
                        allErrs = append(allErrs, field.Invalid(fldPath, fldPath.Child("dataSource"),
                                "must match dataSourceRef"))
                }
        }
        if spec.VolumeAttributesClassName != nil && len(*spec.VolumeAttributesClassName) > 0 && opts.EnableVolumeAttributesClass {
                for _, msg := range ValidateClassName(*spec.VolumeAttributesClassName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("volumeAttributesClassName"), *spec.VolumeAttributesClassName, msg))
                }
        }

        return allErrs
}

func isDataSourceEqualDataSourceRef(dataSource *core.TypedLocalObjectReference, dataSourceRef *core.TypedObjectReference) bool {
        return reflect.DeepEqual(dataSource.APIGroup, dataSourceRef.APIGroup) && dataSource.Kind == dataSourceRef.Kind && dataSource.Name == dataSourceRef.Name
}

// ValidatePersistentVolumeClaimUpdate validates an update to a PersistentVolumeClaim
func ValidatePersistentVolumeClaimUpdate(newPvc, oldPvc *core.PersistentVolumeClaim, opts PersistentVolumeClaimSpecValidationOptions) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newPvc.ObjectMeta, &oldPvc.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidatePersistentVolumeClaim(newPvc, opts)...)
        newPvcClone := newPvc.DeepCopy()
        oldPvcClone := oldPvc.DeepCopy()

        // PVController needs to update PVC.Spec w/ VolumeName.
        // Claims are immutable in order to enforce quota, range limits, etc. without gaming the system.
        if len(oldPvc.Spec.VolumeName) == 0 {
                // volumeName changes are allowed once.
                oldPvcClone.Spec.VolumeName = newPvcClone.Spec.VolumeName // +k8s:verify-mutation:reason=clone
        }

        if validateStorageClassUpgradeFromAnnotation(oldPvcClone.Annotations, newPvcClone.Annotations,
                oldPvcClone.Spec.StorageClassName, newPvcClone.Spec.StorageClassName) {
                newPvcClone.Spec.StorageClassName = nil
                metav1.SetMetaDataAnnotation(&newPvcClone.ObjectMeta, core.BetaStorageClassAnnotation, oldPvcClone.Annotations[core.BetaStorageClassAnnotation])
        } else {
                // storageclass annotation should be immutable after creation
                // TODO: remove Beta when no longer needed
                allErrs = append(allErrs, ValidateImmutableAnnotation(newPvc.ObjectMeta.Annotations[v1.BetaStorageClassAnnotation], oldPvc.ObjectMeta.Annotations[v1.BetaStorageClassAnnotation], v1.BetaStorageClassAnnotation, field.NewPath("metadata"))...)

                // If update from annotation to attribute failed we can attempt try to validate update from nil value.
                if validateStorageClassUpgradeFromNil(oldPvc.Annotations, oldPvc.Spec.StorageClassName, newPvc.Spec.StorageClassName, opts) {
                        newPvcClone.Spec.StorageClassName = oldPvcClone.Spec.StorageClassName // +k8s:verify-mutation:reason=clone
                }
                // TODO: add a specific error with a hint that storage class name can not be changed
                // (instead of letting spec comparison below return generic field forbidden error)
        }

        // lets make sure storage values are same.
        if newPvc.Status.Phase == core.ClaimBound && newPvcClone.Spec.Resources.Requests != nil {
                newPvcClone.Spec.Resources.Requests["storage"] = oldPvc.Spec.Resources.Requests["storage"] // +k8s:verify-mutation:reason=clone
        }
        // lets make sure volume attributes class name is same.
        if newPvc.Status.Phase == core.ClaimBound {
                newPvcClone.Spec.VolumeAttributesClassName = oldPvcClone.Spec.VolumeAttributesClassName // +k8s:verify-mutation:reason=clone
        }

        oldSize := oldPvc.Spec.Resources.Requests["storage"]
        newSize := newPvc.Spec.Resources.Requests["storage"]
        statusSize := oldPvc.Status.Capacity["storage"]

        if !apiequality.Semantic.DeepEqual(newPvcClone.Spec, oldPvcClone.Spec) {
                specDiff := diff.Diff(oldPvcClone.Spec, newPvcClone.Spec)
                allErrs = append(allErrs, field.Forbidden(field.NewPath("spec"), fmt.Sprintf("spec is immutable after creation except resources.requests and volumeAttributesClassName for bound claims\n%v", specDiff)))
        }
        if newSize.Cmp(oldSize) < 0 {
                if !opts.EnableRecoverFromExpansionFailure {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "resources", "requests", "storage"), "field can not be less than previous value"))
                } else {
                        // This validation permits reducing pvc requested size up to capacity recorded in pvc.status
                        // so that users can recover from volume expansion failure, but Kubernetes does not actually
                        // support volume shrinking
                        if newSize.Cmp(statusSize) <= 0 {
                                allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "resources", "requests", "storage"), "field can not be less than status.capacity"))
                        }
                }
        }

        allErrs = append(allErrs, ValidateImmutableField(newPvc.Spec.VolumeMode, oldPvc.Spec.VolumeMode, field.NewPath("volumeMode"))...)

        if !apiequality.Semantic.DeepEqual(oldPvc.Spec.VolumeAttributesClassName, newPvc.Spec.VolumeAttributesClassName) {
                if !utilfeature.DefaultFeatureGate.Enabled(features.VolumeAttributesClass) {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "volumeAttributesClassName"), "update is forbidden when the VolumeAttributesClass feature gate is disabled"))
                }
                if opts.EnableVolumeAttributesClass {
                        // Forbid removing VAC once one is successfully applied.
                        if oldPvc.Status.CurrentVolumeAttributesClassName != nil {
                                if newPvc.Spec.VolumeAttributesClassName == nil {
                                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "volumeAttributesClassName"), "update to nil is forbidden when status.currentVolumeAttributesClassName is not nil"))
                                } else if len(*newPvc.Spec.VolumeAttributesClassName) == 0 {
                                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "volumeAttributesClassName"), "update to empty string is forbidden when status.currentVolumeAttributesClassName is not nil"))
                                }
                        }
                }
        }

        return allErrs
}

// Provide an upgrade path from PVC with storage class specified in beta
// annotation to storage class specified in attribute. We allow update of
// StorageClassName only if following four conditions are met at the same time:
// 1. The old pvc's StorageClassAnnotation is set
// 2. The old pvc's StorageClassName is not set
// 3. The new pvc's StorageClassName is set and equal to the old value in annotation
// 4. If the new pvc's StorageClassAnnotation is set,it must be equal to the old pv/pvc's StorageClassAnnotation
func validateStorageClassUpgradeFromAnnotation(oldAnnotations, newAnnotations map[string]string, oldScName, newScName *string) bool {
        oldSc, oldAnnotationExist := oldAnnotations[core.BetaStorageClassAnnotation]
        newScInAnnotation, newAnnotationExist := newAnnotations[core.BetaStorageClassAnnotation]
        return oldAnnotationExist /* condition 1 */ &&
                oldScName == nil /* condition 2*/ &&
                (newScName != nil && *newScName == oldSc) /* condition 3 */ &&
                (!newAnnotationExist || newScInAnnotation == oldSc) /* condition 4 */
}

// Provide an upgrade path from PVC with nil storage class. We allow update of
// StorageClassName only if following four conditions are met at the same time:
// 1. The new pvc's StorageClassName is not nil
// 2. The old pvc's StorageClassName is nil
// 3. The old pvc either does not have beta annotation set, or the beta annotation matches new pvc's StorageClassName
func validateStorageClassUpgradeFromNil(oldAnnotations map[string]string, oldScName, newScName *string, opts PersistentVolumeClaimSpecValidationOptions) bool {
        oldAnnotation, oldAnnotationExist := oldAnnotations[core.BetaStorageClassAnnotation]
        return newScName != nil /* condition 1 */ &&
                oldScName == nil /* condition 2 */ &&
                (!oldAnnotationExist || *newScName == oldAnnotation) /* condition 3 */
}

func validatePersistentVolumeClaimResourceKey(value string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, msg := range validation.IsQualifiedName(value) {
                allErrs = append(allErrs, field.Invalid(fldPath, value, msg))
        }
        if len(allErrs) != 0 {
                return allErrs
        }
        // For native resource names such as - either unprefixed names or with kubernetes.io prefix,
        // only allowed value is storage
        if helper.IsNativeResource(core.ResourceName(value)) {
                if core.ResourceName(value) != core.ResourceStorage {
                        return append(allErrs, field.NotSupported(fldPath, value, []core.ResourceName{core.ResourceStorage}))
                }
        }
        return allErrs
}

var resizeStatusSet = sets.New(core.PersistentVolumeClaimControllerResizeInProgress,
        core.PersistentVolumeClaimControllerResizeInfeasible,
        core.PersistentVolumeClaimNodeResizePending,
        core.PersistentVolumeClaimNodeResizeInProgress,
        core.PersistentVolumeClaimNodeResizeInfeasible)

// ValidatePersistentVolumeClaimStatusUpdate validates an update to status of a PersistentVolumeClaim
func ValidatePersistentVolumeClaimStatusUpdate(newPvc, oldPvc *core.PersistentVolumeClaim, validationOpts PersistentVolumeClaimSpecValidationOptions) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newPvc.ObjectMeta, &oldPvc.ObjectMeta, field.NewPath("metadata"))
        if len(newPvc.ResourceVersion) == 0 {
                allErrs = append(allErrs, field.Required(field.NewPath("resourceVersion"), ""))
        }
        if len(newPvc.Spec.AccessModes) == 0 {
                allErrs = append(allErrs, field.Required(field.NewPath("Spec", "accessModes"), ""))
        }

        capPath := field.NewPath("status", "capacity")
        for r, qty := range newPvc.Status.Capacity {
                allErrs = append(allErrs, validateBasicResource(qty, capPath.Key(string(r)))...)
        }
        if validationOpts.EnableRecoverFromExpansionFailure {
                resizeStatusPath := field.NewPath("status", "allocatedResourceStatuses")
                if newPvc.Status.AllocatedResourceStatuses != nil {
                        resizeStatus := newPvc.Status.AllocatedResourceStatuses
                        for k, v := range resizeStatus {
                                if errs := validatePersistentVolumeClaimResourceKey(k.String(), resizeStatusPath); len(errs) > 0 {
                                        allErrs = append(allErrs, errs...)
                                }
                                if !resizeStatusSet.Has(v) {
                                        allErrs = append(allErrs, field.NotSupported(resizeStatusPath, k, sets.List(resizeStatusSet)))
                                        continue
                                }
                        }
                }
                allocPath := field.NewPath("status", "allocatedResources")
                for r, qty := range newPvc.Status.AllocatedResources {
                        if errs := validatePersistentVolumeClaimResourceKey(r.String(), allocPath); len(errs) > 0 {
                                allErrs = append(allErrs, errs...)
                                continue
                        }

                        if errs := validateBasicResource(qty, allocPath.Key(string(r))); len(errs) > 0 {
                                allErrs = append(allErrs, errs...)
                        } else {
                                allErrs = append(allErrs, ValidateResourceQuantityValue(core.ResourceStorage, qty, allocPath.Key(string(r)))...)
                        }
                }
        }
        return allErrs
}

var supportedPortProtocols = sets.New(
        core.ProtocolTCP,
        core.ProtocolUDP,
        core.ProtocolSCTP)

func validateContainerPorts(ports []core.ContainerPort, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        allNames := sets.Set[string]{}
        for i, port := range ports {
                idxPath := fldPath.Index(i)
                if len(port.Name) > 0 {
                        if msgs := validation.IsValidPortName(port.Name); len(msgs) != 0 {
                                for i = range msgs {
                                        allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), port.Name, msgs[i]))
                                }
                        } else if allNames.Has(port.Name) {
                                allErrs = append(allErrs, field.Duplicate(idxPath.Child("name"), port.Name))
                        } else {
                                allNames.Insert(port.Name)
                        }
                }
                if port.ContainerPort == 0 {
                        allErrs = append(allErrs, field.Required(idxPath.Child("containerPort"), ""))
                } else {
                        for _, msg := range validation.IsValidPortNum(int(port.ContainerPort)) {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("containerPort"), port.ContainerPort, msg))
                        }
                }
                if port.HostPort != 0 {
                        for _, msg := range validation.IsValidPortNum(int(port.HostPort)) {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("hostPort"), port.HostPort, msg))
                        }
                }
                if len(port.Protocol) == 0 {
                        allErrs = append(allErrs, field.Required(idxPath.Child("protocol"), ""))
                } else if !supportedPortProtocols.Has(port.Protocol) {
                        allErrs = append(allErrs, field.NotSupported(idxPath.Child("protocol"), port.Protocol, sets.List(supportedPortProtocols)))
                }
        }
        return allErrs
}

// ValidateEnv validates env vars
func ValidateEnv(vars []core.EnvVar, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        for i, ev := range vars {
                idxPath := fldPath.Index(i)
                if len(ev.Name) == 0 {
                        allErrs = append(allErrs, field.Required(idxPath.Child("name"), ""))
                } else {
                        if opts.AllowRelaxedEnvironmentVariableValidation {
                                for _, msg := range validation.IsRelaxedEnvVarName(ev.Name) {
                                        allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), ev.Name, msg))
                                }
                        } else {
                                for _, msg := range validation.IsEnvVarName(ev.Name) {
                                        allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), ev.Name, msg))
                                }
                        }
                }
                allErrs = append(allErrs, validateEnvVarValueFrom(ev, idxPath.Child("valueFrom"), opts)...)
        }
        return allErrs
}

var validEnvDownwardAPIFieldPathExpressions = sets.New(
        "metadata.name",
        "metadata.namespace",
        "metadata.uid",
        "spec.nodeName",
        "spec.serviceAccountName",
        "status.hostIP",
        "status.hostIPs",
        "status.podIP",
        "status.podIPs",
)

var validContainerResourceFieldPathExpressions = sets.New(
        "limits.cpu",
        "limits.memory",
        "limits.ephemeral-storage",
        "requests.cpu",
        "requests.memory",
        "requests.ephemeral-storage",
)

var validContainerResourceFieldPathPrefixesWithDownwardAPIHugePages = sets.New(hugepagesRequestsPrefixDownwardAPI, hugepagesLimitsPrefixDownwardAPI)

const hugepagesRequestsPrefixDownwardAPI string = `requests.hugepages-`
const hugepagesLimitsPrefixDownwardAPI string = `limits.hugepages-`

func validateEnvVarValueFrom(ev core.EnvVar, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if ev.ValueFrom == nil {
                return allErrs
        }

        numSources := 0

        if ev.ValueFrom.FieldRef != nil {
                numSources++
                allErrs = append(allErrs, validateObjectFieldSelector(ev.ValueFrom.FieldRef, &validEnvDownwardAPIFieldPathExpressions, fldPath.Child("fieldRef"))...)
        }
        if ev.ValueFrom.ResourceFieldRef != nil {
                numSources++
                localValidContainerResourceFieldPathPrefixes := validContainerResourceFieldPathPrefixesWithDownwardAPIHugePages
                allErrs = append(allErrs, validateContainerResourceFieldSelector(ev.ValueFrom.ResourceFieldRef, &validContainerResourceFieldPathExpressions, &localValidContainerResourceFieldPathPrefixes, fldPath.Child("resourceFieldRef"), false)...)
        }
        if ev.ValueFrom.ConfigMapKeyRef != nil {
                numSources++
                allErrs = append(allErrs, validateConfigMapKeySelector(ev.ValueFrom.ConfigMapKeyRef, fldPath.Child("configMapKeyRef"))...)
        }
        if ev.ValueFrom.SecretKeyRef != nil {
                numSources++
                allErrs = append(allErrs, validateSecretKeySelector(ev.ValueFrom.SecretKeyRef, fldPath.Child("secretKeyRef"))...)
        }

        if ev.ValueFrom.FileKeyRef != nil {
                numSources++
                allErrs = append(allErrs, validateFileKeySelector(ev.ValueFrom.FileKeyRef, fldPath.Child("fileKeyRef"))...)
        }

        if numSources == 0 {
                if opts.AllowEnvFilesValidation {
                        allErrs = append(allErrs, field.Invalid(fldPath, "", "must specify one of: `fieldRef`, `resourceFieldRef`, `configMapKeyRef`, `secretKeyRef` or `fileKeyRef`"))
                } else {
                        allErrs = append(allErrs, field.Invalid(fldPath, "", "must specify one of: `fieldRef`, `resourceFieldRef`, `configMapKeyRef` or `secretKeyRef`"))
                }
        } else if len(ev.Value) != 0 {
                if numSources != 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath, "", "may not be specified when `value` is not empty"))
                }
        } else if numSources > 1 {
                allErrs = append(allErrs, field.Invalid(fldPath, "", "may not have more than one field specified at a time"))
        }

        return allErrs
}

func validateObjectFieldSelector(fs *core.ObjectFieldSelector, expressions *sets.Set[string], fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(fs.APIVersion) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("apiVersion"), ""))
                return allErrs
        }
        if len(fs.FieldPath) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("fieldPath"), ""))
                return allErrs
        }

        internalFieldPath, _, err := podshelper.ConvertDownwardAPIFieldLabel(fs.APIVersion, fs.FieldPath, "")
        if err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("fieldPath"), fs.FieldPath, fmt.Sprintf("error converting fieldPath: %v", err)))
                return allErrs
        }

        if path, subscript, ok := fieldpath.SplitMaybeSubscriptedPath(internalFieldPath); ok {
                switch path {
                case "metadata.annotations":
                        allErrs = append(allErrs, ValidateQualifiedName(strings.ToLower(subscript), fldPath)...)
                case "metadata.labels":
                        allErrs = append(allErrs, ValidateQualifiedName(subscript, fldPath)...)
                default:
                        allErrs = append(allErrs, field.Invalid(fldPath, path, "does not support subscript"))
                }
        } else if !expressions.Has(path) {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("fieldPath"), path, sets.List(*expressions)))
                return allErrs
        }

        return allErrs
}

func validateContainerResourceFieldSelector(fs *core.ResourceFieldSelector, expressions *sets.Set[string], prefixes *sets.Set[string], fldPath *field.Path, volume bool) field.ErrorList {
        allErrs := field.ErrorList{}

        if volume && len(fs.ContainerName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("containerName"), ""))
        } else if len(fs.Resource) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("resource"), ""))
        } else if !expressions.Has(fs.Resource) {
                // check if the prefix is present
                foundPrefix := false
                if prefixes != nil {
                        for _, prefix := range sets.List(*prefixes) {
                                if strings.HasPrefix(fs.Resource, prefix) {
                                        foundPrefix = true
                                }
                        }
                }
                if !foundPrefix {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("resource"), fs.Resource, sets.List(*expressions)))
                }
        }
        allErrs = append(allErrs, validateContainerResourceDivisor(fs.Resource, fs.Divisor, fldPath)...)
        return allErrs
}

func ValidateEnvFrom(vars []core.EnvFromSource, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        for i, ev := range vars {
                idxPath := fldPath.Index(i)
                if len(ev.Prefix) > 0 {
                        if opts.AllowRelaxedEnvironmentVariableValidation {
                                for _, msg := range validation.IsRelaxedEnvVarName(ev.Prefix) {
                                        allErrs = append(allErrs, field.Invalid(idxPath.Child("prefix"), ev.Prefix, msg))
                                }
                        } else {
                                for _, msg := range validation.IsEnvVarName(ev.Prefix) {
                                        allErrs = append(allErrs, field.Invalid(idxPath.Child("prefix"), ev.Prefix, msg))
                                }
                        }
                }

                numSources := 0
                if ev.ConfigMapRef != nil {
                        numSources++
                        allErrs = append(allErrs, validateConfigMapEnvSource(ev.ConfigMapRef, idxPath.Child("configMapRef"))...)
                }
                if ev.SecretRef != nil {
                        numSources++
                        allErrs = append(allErrs, validateSecretEnvSource(ev.SecretRef, idxPath.Child("secretRef"))...)
                }

                if numSources == 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath, "", "must specify one of: `configMapRef` or `secretRef`"))
                } else if numSources > 1 {
                        allErrs = append(allErrs, field.Invalid(fldPath, "", "may not have more than one field specified at a time"))
                }
        }
        return allErrs
}

func validateConfigMapEnvSource(configMapSource *core.ConfigMapEnvSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(configMapSource.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        } else {
                for _, msg := range ValidateConfigMapName(configMapSource.Name, true) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), configMapSource.Name, msg))
                }
        }
        return allErrs
}

func validateSecretEnvSource(secretSource *core.SecretEnvSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(secretSource.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        } else {
                for _, msg := range ValidateSecretName(secretSource.Name, true) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), secretSource.Name, msg))
                }
        }
        return allErrs
}

var validContainerResourceDivisorForCPU = sets.New("1m", "1")
var validContainerResourceDivisorForMemory = sets.New(
        "1",
        "1k", "1M", "1G", "1T", "1P", "1E",
        "1Ki", "1Mi", "1Gi", "1Ti", "1Pi", "1Ei")
var validContainerResourceDivisorForHugePages = sets.New(
        "1",
        "1k", "1M", "1G", "1T", "1P", "1E",
        "1Ki", "1Mi", "1Gi", "1Ti", "1Pi", "1Ei")
var validContainerResourceDivisorForEphemeralStorage = sets.New(
        "1",
        "1k", "1M", "1G", "1T", "1P", "1E",
        "1Ki", "1Mi", "1Gi", "1Ti", "1Pi", "1Ei")

func validateContainerResourceDivisor(rName string, divisor resource.Quantity, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        unsetDivisor := resource.Quantity{}
        if unsetDivisor.Cmp(divisor) == 0 {
                return allErrs
        }
        switch rName {
        case "limits.cpu", "requests.cpu":
                if !validContainerResourceDivisorForCPU.Has(divisor.String()) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("divisor"), rName, "only divisor's values 1m and 1 are supported with the cpu resource"))
                }
        case "limits.memory", "requests.memory":
                if !validContainerResourceDivisorForMemory.Has(divisor.String()) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("divisor"), rName, "only divisor's values 1, 1k, 1M, 1G, 1T, 1P, 1E, 1Ki, 1Mi, 1Gi, 1Ti, 1Pi, 1Ei are supported with the memory resource"))
                }
        case "limits.ephemeral-storage", "requests.ephemeral-storage":
                if !validContainerResourceDivisorForEphemeralStorage.Has(divisor.String()) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("divisor"), rName, "only divisor's values 1, 1k, 1M, 1G, 1T, 1P, 1E, 1Ki, 1Mi, 1Gi, 1Ti, 1Pi, 1Ei are supported with the local ephemeral storage resource"))
                }
        }
        if strings.HasPrefix(rName, hugepagesRequestsPrefixDownwardAPI) || strings.HasPrefix(rName, hugepagesLimitsPrefixDownwardAPI) {
                if !validContainerResourceDivisorForHugePages.Has(divisor.String()) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("divisor"), rName, "only divisor's values 1, 1k, 1M, 1G, 1T, 1P, 1E, 1Ki, 1Mi, 1Gi, 1Ti, 1Pi, 1Ei are supported with the hugepages resource"))
                }
        }
        return allErrs
}

func validateConfigMapKeySelector(s *core.ConfigMapKeySelector, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        nameFn := ValidateNameFunc(ValidateSecretName)
        for _, msg := range nameFn(s.Name, false) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), s.Name, msg))
        }
        if len(s.Key) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("key"), ""))
        } else {
                for _, msg := range validation.IsConfigMapKey(s.Key) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("key"), s.Key, msg))
                }
        }

        return allErrs
}

func validateSecretKeySelector(s *core.SecretKeySelector, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        nameFn := ValidateNameFunc(ValidateSecretName)
        for _, msg := range nameFn(s.Name, false) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), s.Name, msg))
        }
        if len(s.Key) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("key"), ""))
        } else {
                for _, msg := range validation.IsConfigMapKey(s.Key) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("key"), s.Key, msg))
                }
        }

        return allErrs
}

func validateFileKeySelector(s *core.FileKeySelector, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        // The Key field must be non-empty and must be a valid environment variable name.
        if len(s.Key) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("key"), ""))
        } else {
                for _, msg := range validation.IsRelaxedEnvVarName(s.Key) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("key"), s.Key, msg))
                }
        }

        // The VolumeName field must be non-empty and must be a valid DNS1123 label.
        if len(s.VolumeName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("volumeName"), ""))
        } else {
                allErrs = append(allErrs, ValidateDNS1123Label(s.VolumeName, fldPath.Child("volumeName"))...)
        }

        // The Path field must be non-empty and must not contain backsteps ("..").
        if len(s.Path) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("path"), ""))
        } else {
                allErrs = append(allErrs, validatePathNoBacksteps(s.Path, fldPath.Child("path"))...)
        }

        return allErrs
}

func GetVolumeMountMap(mounts []core.VolumeMount) map[string]string {
        volmounts := make(map[string]string)

        for _, mnt := range mounts {
                volmounts[mnt.Name] = mnt.MountPath
        }

        return volmounts
}

func GetVolumeDeviceMap(devices []core.VolumeDevice) map[string]string {
        volDevices := make(map[string]string)

        for _, dev := range devices {
                volDevices[dev.Name] = dev.DevicePath
        }

        return volDevices
}

func ValidateVolumeMounts(mounts []core.VolumeMount, voldevices map[string]string, volumes map[string]core.VolumeSource, container *core.Container, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        mountpoints := sets.New[string]()

        for i, mnt := range mounts {
                idxPath := fldPath.Index(i)
                if len(mnt.Name) == 0 {
                        allErrs = append(allErrs, field.Required(idxPath.Child("name"), ""))
                }
                if !IsMatchedVolume(mnt.Name, volumes) {
                        allErrs = append(allErrs, field.NotFound(idxPath.Child("name"), mnt.Name))
                }
                if len(mnt.MountPath) == 0 {
                        allErrs = append(allErrs, field.Required(idxPath.Child("mountPath"), ""))
                }
                if mountpoints.Has(mnt.MountPath) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("mountPath"), mnt.MountPath, "must be unique"))
                }
                mountpoints.Insert(mnt.MountPath)

                // check for overlap with VolumeDevice
                if mountNameAlreadyExists(mnt.Name, voldevices) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), mnt.Name, "must not already exist in volumeDevices"))
                }
                if mountPathAlreadyExists(mnt.MountPath, voldevices) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("mountPath"), mnt.MountPath, "must not already exist as a path in volumeDevices"))
                }

                if len(mnt.SubPath) > 0 {
                        allErrs = append(allErrs, validateLocalDescendingPath(mnt.SubPath, fldPath.Child("subPath"))...)
                }

                if len(mnt.SubPathExpr) > 0 {
                        if len(mnt.SubPath) > 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("subPathExpr"), mnt.SubPathExpr, "subPathExpr and subPath are mutually exclusive"))
                        }

                        allErrs = append(allErrs, validateLocalDescendingPath(mnt.SubPathExpr, fldPath.Child("subPathExpr"))...)
                }

                if mnt.MountPropagation != nil {
                        allErrs = append(allErrs, validateMountPropagation(mnt.MountPropagation, container, fldPath.Child("mountPropagation"))...)
                }
                allErrs = append(allErrs, validateMountRecursiveReadOnly(mnt, fldPath.Child("recursiveReadOnly"))...)
        }
        return allErrs
}

func ValidateVolumeDevices(devices []core.VolumeDevice, volmounts map[string]string, volumes map[string]core.VolumeSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        devicepath := sets.New[string]()
        devicename := sets.New[string]()

        for i, dev := range devices {
                idxPath := fldPath.Index(i)
                devName := dev.Name
                devPath := dev.DevicePath
                didMatch, isPVC := isMatchedDevice(devName, volumes)
                if len(devName) == 0 {
                        allErrs = append(allErrs, field.Required(idxPath.Child("name"), ""))
                }
                if devicename.Has(devName) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), devName, "must be unique"))
                }
                // Must be based on PersistentVolumeClaim (PVC reference or generic ephemeral inline volume)
                if didMatch && !isPVC {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), devName, "can only use volume source type of PersistentVolumeClaim or Ephemeral for block mode"))
                }
                if !didMatch {
                        allErrs = append(allErrs, field.NotFound(idxPath.Child("name"), devName))
                }
                if len(devPath) == 0 {
                        allErrs = append(allErrs, field.Required(idxPath.Child("devicePath"), ""))
                }
                if devicepath.Has(devPath) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("devicePath"), devPath, "must be unique"))
                }
                if len(devPath) > 0 && len(validatePathNoBacksteps(devPath, fldPath.Child("devicePath"))) > 0 {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("devicePath"), devPath, "can not contain backsteps ('..')"))
                } else {
                        devicepath.Insert(devPath)
                }
                // check for overlap with VolumeMount
                if deviceNameAlreadyExists(devName, volmounts) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), devName, "must not already exist in volumeMounts"))
                }
                if devicePathAlreadyExists(devPath, volmounts) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("devicePath"), devPath, "must not already exist as a path in volumeMounts"))
                }
                if len(devName) > 0 {
                        devicename.Insert(devName)
                }
        }
        return allErrs
}

func validatePodResourceClaims(podMeta *metav1.ObjectMeta, claims []core.PodResourceClaim, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        podClaimNames := sets.New[string]()
        for i, claim := range claims {
                allErrs = append(allErrs, validatePodResourceClaim(podMeta, claim, &podClaimNames, fldPath.Index(i))...)
        }
        return allErrs
}

// gatherPodResourceClaimNames returns a set of all non-empty
// PodResourceClaim.Name values. Validation that those names are valid is
// handled by validatePodResourceClaims.
func gatherPodResourceClaimNames(claims []core.PodResourceClaim) sets.Set[string] {
        podClaimNames := sets.Set[string]{}
        for _, claim := range claims {
                if claim.Name != "" {
                        podClaimNames.Insert(claim.Name)
                }
        }
        return podClaimNames
}

func validatePodResourceClaim(podMeta *metav1.ObjectMeta, claim core.PodResourceClaim, podClaimNames *sets.Set[string], fldPath *field.Path) field.ErrorList {
        // static pods don't support resource claims
        if podMeta != nil {
                if _, ok := podMeta.Annotations[core.MirrorPodAnnotationKey]; ok {
                        return field.ErrorList{field.Forbidden(field.NewPath(""), "static pods do not support resource claims")}
                }
        }

        var allErrs field.ErrorList
        if claim.Name == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        } else if podClaimNames.Has(claim.Name) {
                allErrs = append(allErrs, field.Duplicate(fldPath.Child("name"), claim.Name))
        } else {
                allErrs = append(allErrs, ValidateDNS1123Label(claim.Name, fldPath.Child("name"))...)
                podClaimNames.Insert(claim.Name)
        }
        if claim.ResourceClaimName != nil && claim.ResourceClaimTemplateName != nil {
                allErrs = append(allErrs, field.Invalid(fldPath, claim, "at most one of `resourceClaimName` or `resourceClaimTemplateName` may be specified"))
        }
        if claim.ResourceClaimName == nil && claim.ResourceClaimTemplateName == nil {
                allErrs = append(allErrs, field.Invalid(fldPath, claim, "must specify one of: `resourceClaimName`, `resourceClaimTemplateName`"))
        }
        if claim.ResourceClaimName != nil {
                for _, detail := range ValidateResourceClaimName(*claim.ResourceClaimName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("resourceClaimName"), *claim.ResourceClaimName, detail))
                }
        }
        if claim.ResourceClaimTemplateName != nil {
                for _, detail := range ValidateResourceClaimTemplateName(*claim.ResourceClaimTemplateName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("resourceClaimTemplateName"), *claim.ResourceClaimTemplateName, detail))
                }
        }
        return allErrs
}

func validateLivenessProbe(probe *core.Probe, gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if probe == nil {
                return allErrs
        }
        allErrs = append(allErrs, validateProbe(probe, gracePeriod, fldPath, opts)...)
        if probe.SuccessThreshold != 1 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("successThreshold"), probe.SuccessThreshold, "must be 1"))
        }
        return allErrs
}

func validateReadinessProbe(probe *core.Probe, gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if probe == nil {
                return allErrs
        }
        allErrs = append(allErrs, validateProbe(probe, gracePeriod, fldPath, opts)...)
        if probe.TerminationGracePeriodSeconds != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("terminationGracePeriodSeconds"), probe.TerminationGracePeriodSeconds, "must not be set for readinessProbes"))
        }
        return allErrs
}

func validateStartupProbe(probe *core.Probe, gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if probe == nil {
                return allErrs
        }
        allErrs = append(allErrs, validateProbe(probe, gracePeriod, fldPath, opts)...)
        if probe.SuccessThreshold != 1 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("successThreshold"), probe.SuccessThreshold, "must be 1"))
        }
        return allErrs
}

func validateProbe(probe *core.Probe, gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if probe == nil {
                return allErrs
        }
        allErrs = append(allErrs, validateHandler(handlerFromProbe(&probe.ProbeHandler), gracePeriod, fldPath, opts)...)

        allErrs = append(allErrs, ValidateNonnegativeField(int64(probe.InitialDelaySeconds), fldPath.Child("initialDelaySeconds"))...)
        allErrs = append(allErrs, ValidateNonnegativeField(int64(probe.TimeoutSeconds), fldPath.Child("timeoutSeconds"))...)
        allErrs = append(allErrs, ValidateNonnegativeField(int64(probe.PeriodSeconds), fldPath.Child("periodSeconds"))...)
        allErrs = append(allErrs, ValidateNonnegativeField(int64(probe.SuccessThreshold), fldPath.Child("successThreshold"))...)
        allErrs = append(allErrs, ValidateNonnegativeField(int64(probe.FailureThreshold), fldPath.Child("failureThreshold"))...)
        if probe.TerminationGracePeriodSeconds != nil && *probe.TerminationGracePeriodSeconds <= 0 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("terminationGracePeriodSeconds"), *probe.TerminationGracePeriodSeconds, "must be greater than 0"))
        }
        return allErrs
}

func validateInitContainerRestartPolicy(restartPolicy *core.ContainerRestartPolicy, restartRules []core.ContainerRestartRule, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        var allErrors field.ErrorList

        if restartPolicy == nil {
                return allErrors
        }
        if opts.AllowContainerRestartPolicyRules {
                switch *restartPolicy {
                case core.ContainerRestartPolicyAlways:
                        // Sidecar containers should not have restart policy rules
                        if len(restartRules) > 0 {
                                allErrors = append(allErrors, field.Forbidden(fldPath.Child("restartPolicyRules"), "restartPolicyRules are not allowed for init containers with restart policy Always"))
                        }
                default:
                        allErrors = append(allErrors, validateContainerRestartPolicy(restartPolicy, restartRules, fldPath)...)
                }
        } else {
                switch *restartPolicy {
                case core.ContainerRestartPolicyAlways:
                        break
                default:
                        validValues := []core.ContainerRestartPolicy{core.ContainerRestartPolicyAlways}
                        allErrors = append(allErrors, field.NotSupported(fldPath.Child("restartPolicy"), *restartPolicy, validValues))
                }
        }

        return allErrors
}

type commonHandler struct {
        Exec      *core.ExecAction
        HTTPGet   *core.HTTPGetAction
        TCPSocket *core.TCPSocketAction
        GRPC      *core.GRPCAction
        Sleep     *core.SleepAction
}

func handlerFromProbe(ph *core.ProbeHandler) commonHandler {
        return commonHandler{
                Exec:      ph.Exec,
                HTTPGet:   ph.HTTPGet,
                TCPSocket: ph.TCPSocket,
                GRPC:      ph.GRPC,
        }
}

func handlerFromLifecycle(lh *core.LifecycleHandler) commonHandler {
        return commonHandler{
                Exec:      lh.Exec,
                HTTPGet:   lh.HTTPGet,
                TCPSocket: lh.TCPSocket,
                Sleep:     lh.Sleep,
        }
}

func validateSleepAction(sleep *core.SleepAction, gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrors := field.ErrorList{}
        // We allow gracePeriod to be nil here because the pod in which this SleepAction
        // is defined might have an invalid grace period defined, and we don't want to
        // flag another error here when the real problem will already be flagged.
        if opts.AllowPodLifecycleSleepActionZeroValue {
                if gracePeriod != nil && (sleep.Seconds < 0 || sleep.Seconds > *gracePeriod) {
                        invalidStr := fmt.Sprintf("must be non-negative and less than terminationGracePeriodSeconds (%d)", *gracePeriod)
                        allErrors = append(allErrors, field.Invalid(fldPath, sleep.Seconds, invalidStr))
                }
        } else {
                if gracePeriod != nil && (sleep.Seconds <= 0 || sleep.Seconds > *gracePeriod) {
                        invalidStr := fmt.Sprintf("must be greater than 0 and less than terminationGracePeriodSeconds (%d). Enable AllowPodLifecycleSleepActionZeroValue feature gate for zero sleep.", *gracePeriod)
                        allErrors = append(allErrors, field.Invalid(fldPath, sleep.Seconds, invalidStr))
                }
        }
        return allErrors
}

func validateClientIPAffinityConfig(config *core.SessionAffinityConfig, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if config == nil {
                allErrs = append(allErrs, field.Required(fldPath, fmt.Sprintf("when session affinity type is %s", core.ServiceAffinityClientIP)))
                return allErrs
        }
        if config.ClientIP == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("clientIP"), fmt.Sprintf("when session affinity type is %s", core.ServiceAffinityClientIP)))
                return allErrs
        }
        if config.ClientIP.TimeoutSeconds == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("clientIP").Child("timeoutSeconds"), fmt.Sprintf("when session affinity type is %s", core.ServiceAffinityClientIP)))
                return allErrs
        }
        allErrs = append(allErrs, validateAffinityTimeout(config.ClientIP.TimeoutSeconds, fldPath.Child("clientIP").Child("timeoutSeconds"))...)

        return allErrs
}

func validateAffinityTimeout(timeout *int32, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if *timeout <= 0 || *timeout > core.MaxClientIPServiceAffinitySeconds {
                allErrs = append(allErrs, field.Invalid(fldPath, timeout, fmt.Sprintf("must be greater than 0 and less than %d", core.MaxClientIPServiceAffinitySeconds)))
        }
        return allErrs
}

// AccumulateUniqueHostPorts extracts each HostPort of each Container,
// accumulating the results and returning an error if any ports conflict.
func AccumulateUniqueHostPorts(containers []core.Container, accumulator *sets.Set[string], fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        for ci, ctr := range containers {
                idxPath := fldPath.Index(ci)
                portsPath := idxPath.Child("ports")
                for pi := range ctr.Ports {
                        idxPath := portsPath.Index(pi)
                        port := ctr.Ports[pi].HostPort
                        if port == 0 {
                                continue
                        }
                        str := fmt.Sprintf("%s/%s/%d", ctr.Ports[pi].Protocol, ctr.Ports[pi].HostIP, port)
                        if accumulator.Has(str) {
                                allErrs = append(allErrs, field.Duplicate(idxPath.Child("hostPort"), str))
                        } else {
                                accumulator.Insert(str)
                        }
                }
        }
        return allErrs
}

// checkHostPortConflicts checks for colliding Port.HostPort values across
// a slice of containers.
func checkHostPortConflicts(containers []core.Container, fldPath *field.Path) field.ErrorList {
        allPorts := sets.Set[string]{}
        return AccumulateUniqueHostPorts(containers, &allPorts, fldPath)
}

func validateExecAction(exec *core.ExecAction, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        if len(exec.Command) == 0 {
                allErrors = append(allErrors, field.Required(fldPath.Child("command"), ""))
        }
        return allErrors
}

var supportedHTTPSchemes = sets.New(core.URISchemeHTTP, core.URISchemeHTTPS)

func validateHTTPGetAction(http *core.HTTPGetAction, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        if len(http.Path) == 0 {
                allErrors = append(allErrors, field.Required(fldPath.Child("path"), ""))
        }
        allErrors = append(allErrors, ValidatePortNumOrName(http.Port, fldPath.Child("port"))...)
        if !supportedHTTPSchemes.Has(http.Scheme) {
                allErrors = append(allErrors, field.NotSupported(fldPath.Child("scheme"), http.Scheme, sets.List(supportedHTTPSchemes)))
        }
        for _, header := range http.HTTPHeaders {
                for _, msg := range validation.IsHTTPHeaderName(header.Name) {
                        allErrors = append(allErrors, field.Invalid(fldPath.Child("httpHeaders"), header.Name, msg))
                }
        }
        return allErrors
}

func ValidatePortNumOrName(port intstr.IntOrString, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if port.Type == intstr.Int {
                for _, msg := range validation.IsValidPortNum(port.IntValue()) {
                        allErrs = append(allErrs, field.Invalid(fldPath, port.IntValue(), msg))
                }
        } else if port.Type == intstr.String {
                for _, msg := range validation.IsValidPortName(port.StrVal) {
                        allErrs = append(allErrs, field.Invalid(fldPath, port.StrVal, msg))
                }
        } else {
                allErrs = append(allErrs, field.InternalError(fldPath, fmt.Errorf("unknown type: %v", port.Type)))
        }
        return allErrs
}

func validateTCPSocketAction(tcp *core.TCPSocketAction, fldPath *field.Path) field.ErrorList {
        return ValidatePortNumOrName(tcp.Port, fldPath.Child("port"))
}
func validateGRPCAction(grpc *core.GRPCAction, fldPath *field.Path) field.ErrorList {
        return ValidatePortNumOrName(intstr.FromInt32(grpc.Port), fldPath.Child("port"))
}
func validateHandler(handler commonHandler, gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        numHandlers := 0
        allErrors := field.ErrorList{}
        if handler.Exec != nil {
                if numHandlers > 0 {
                        allErrors = append(allErrors, field.Forbidden(fldPath.Child("exec"), "may not specify more than 1 handler type"))
                } else {
                        numHandlers++
                        allErrors = append(allErrors, validateExecAction(handler.Exec, fldPath.Child("exec"))...)
                }
        }
        if handler.HTTPGet != nil {
                if numHandlers > 0 {
                        allErrors = append(allErrors, field.Forbidden(fldPath.Child("httpGet"), "may not specify more than 1 handler type"))
                } else {
                        numHandlers++
                        allErrors = append(allErrors, validateHTTPGetAction(handler.HTTPGet, fldPath.Child("httpGet"))...)
                }
        }
        if handler.TCPSocket != nil {
                if numHandlers > 0 {
                        allErrors = append(allErrors, field.Forbidden(fldPath.Child("tcpSocket"), "may not specify more than 1 handler type"))
                } else {
                        numHandlers++
                        allErrors = append(allErrors, validateTCPSocketAction(handler.TCPSocket, fldPath.Child("tcpSocket"))...)
                }
        }
        if handler.GRPC != nil {
                if numHandlers > 0 {
                        allErrors = append(allErrors, field.Forbidden(fldPath.Child("grpc"), "may not specify more than 1 handler type"))
                } else {
                        numHandlers++
                        allErrors = append(allErrors, validateGRPCAction(handler.GRPC, fldPath.Child("grpc"))...)
                }
        }
        if handler.Sleep != nil {
                if numHandlers > 0 {
                        allErrors = append(allErrors, field.Forbidden(fldPath.Child("sleep"), "may not specify more than 1 handler type"))
                } else {
                        numHandlers++
                        allErrors = append(allErrors, validateSleepAction(handler.Sleep, gracePeriod, fldPath.Child("sleep"), opts)...)
                }
        }
        if numHandlers == 0 {
                allErrors = append(allErrors, field.Required(fldPath, "must specify a handler type"))
        }
        return allErrors
}

var supportedStopSignalsLinux = sets.New(
        core.SIGABRT, core.SIGALRM, core.SIGBUS, core.SIGCHLD,
        core.SIGCLD, core.SIGCONT, core.SIGFPE, core.SIGHUP,
        core.SIGILL, core.SIGINT, core.SIGIO, core.SIGIOT,
        core.SIGKILL, core.SIGPIPE, core.SIGPOLL, core.SIGPROF,
        core.SIGPWR, core.SIGQUIT, core.SIGSEGV, core.SIGSTKFLT,
        core.SIGSTOP, core.SIGSYS, core.SIGTERM, core.SIGTRAP,
        core.SIGTSTP, core.SIGTTIN, core.SIGTTOU, core.SIGURG,
        core.SIGUSR1, core.SIGUSR2, core.SIGVTALRM, core.SIGWINCH,
        core.SIGXCPU, core.SIGXFSZ, core.SIGRTMIN, core.SIGRTMINPLUS1,
        core.SIGRTMINPLUS2, core.SIGRTMINPLUS3, core.SIGRTMINPLUS4,
        core.SIGRTMINPLUS5, core.SIGRTMINPLUS6, core.SIGRTMINPLUS7,
        core.SIGRTMINPLUS8, core.SIGRTMINPLUS9, core.SIGRTMINPLUS10,
        core.SIGRTMINPLUS11, core.SIGRTMINPLUS12, core.SIGRTMINPLUS13,
        core.SIGRTMINPLUS14, core.SIGRTMINPLUS15, core.SIGRTMAXMINUS14,
        core.SIGRTMAXMINUS13, core.SIGRTMAXMINUS12, core.SIGRTMAXMINUS11,
        core.SIGRTMAXMINUS10, core.SIGRTMAXMINUS9, core.SIGRTMAXMINUS8,
        core.SIGRTMAXMINUS7, core.SIGRTMAXMINUS6, core.SIGRTMAXMINUS5,
        core.SIGRTMAXMINUS4, core.SIGRTMAXMINUS3, core.SIGRTMAXMINUS2,
        core.SIGRTMAXMINUS1, core.SIGRTMAX)

var supportedStopSignalsWindows = sets.New(core.SIGKILL, core.SIGTERM)

func validateStopSignal(stopSignal *core.Signal, fldPath *field.Path, os *core.PodOS) field.ErrorList {
        allErrors := field.ErrorList{}

        if os == nil {
                allErrors = append(allErrors, field.Forbidden(fldPath, "may not be set for containers with empty `spec.os.name`"))
        } else if os.Name == core.Windows {
                if !supportedStopSignalsWindows.Has(*stopSignal) {
                        allErrors = append(allErrors, field.NotSupported(fldPath, stopSignal, sets.List(supportedStopSignalsWindows)))
                }
        } else if os.Name == core.Linux {
                if !supportedStopSignalsLinux.Has(*stopSignal) {
                        allErrors = append(allErrors, field.NotSupported(fldPath, stopSignal, sets.List(supportedStopSignalsLinux)))
                }
        }

        return allErrors
}

func validateLifecycle(lifecycle *core.Lifecycle, gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions, os *core.PodOS) field.ErrorList {
        allErrs := field.ErrorList{}
        if lifecycle.PostStart != nil {
                allErrs = append(allErrs, validateHandler(handlerFromLifecycle(lifecycle.PostStart), gracePeriod, fldPath.Child("postStart"), opts)...)
        }
        if lifecycle.PreStop != nil {
                allErrs = append(allErrs, validateHandler(handlerFromLifecycle(lifecycle.PreStop), gracePeriod, fldPath.Child("preStop"), opts)...)
        }
        if lifecycle.StopSignal != nil {
                allErrs = append(allErrs, validateStopSignal(lifecycle.StopSignal, fldPath.Child("stopSignal"), os)...)
        }
        return allErrs
}

var supportedPullPolicies = sets.New(
        core.PullAlways,
        core.PullIfNotPresent,
        core.PullNever)

func validatePullPolicy(policy core.PullPolicy, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}

        switch policy {
        case core.PullAlways, core.PullIfNotPresent, core.PullNever:
                break
        case "":
                allErrors = append(allErrors, field.Required(fldPath, ""))
        default:
                allErrors = append(allErrors, field.NotSupported(fldPath, policy, sets.List(supportedPullPolicies)))
        }

        return allErrors
}

var supportedResizeResources = sets.New(core.ResourceCPU, core.ResourceMemory)
var supportedResizePolicies = sets.New(core.NotRequired, core.RestartContainer)

func validateResizePolicy(policyList []core.ContainerResizePolicy, fldPath *field.Path, podRestartPolicy *core.RestartPolicy) field.ErrorList {
        allErrors := field.ErrorList{}

        // validate that resource name is not repeated, supported resource names and policy values are specified
        resources := make(map[core.ResourceName]bool)
        for i, p := range policyList {
                if _, found := resources[p.ResourceName]; found {
                        allErrors = append(allErrors, field.Duplicate(fldPath.Index(i), p.ResourceName))
                }
                resources[p.ResourceName] = true
                switch p.ResourceName {
                case core.ResourceCPU, core.ResourceMemory:
                case "":
                        allErrors = append(allErrors, field.Required(fldPath, ""))
                default:
                        allErrors = append(allErrors, field.NotSupported(fldPath, p.ResourceName, sets.List(supportedResizeResources)))
                }
                switch p.RestartPolicy {
                case core.NotRequired, core.RestartContainer:
                case "":
                        allErrors = append(allErrors, field.Required(fldPath, ""))
                default:
                        allErrors = append(allErrors, field.NotSupported(fldPath, p.RestartPolicy, sets.List(supportedResizePolicies)))
                }

                if *podRestartPolicy == core.RestartPolicyNever && p.RestartPolicy != core.NotRequired {
                        allErrors = append(allErrors, field.Invalid(fldPath, p.RestartPolicy, "must be 'NotRequired' when `restartPolicy` is 'Never'"))
                }
        }
        return allErrors
}

var supportedContainerRestartPolicies = sets.New(
        core.ContainerRestartPolicyAlways,
        core.ContainerRestartPolicyNever,
        core.ContainerRestartPolicyOnFailure,
)

var supportedContainerRestartPolicyOperators = sets.New(
        core.ContainerRestartRuleOnExitCodesOpIn,
        core.ContainerRestartRuleOnExitCodesOpNotIn,
)

// validateContainerRestartPolicy checks the container-level restartPolicy and restartPolicyRules are valid for
// regular containers and non-sidecar init containers.
func validateContainerRestartPolicy(policy *core.ContainerRestartPolicy, rules []core.ContainerRestartRule, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        restartPolicyFld := fldPath.Child("restartPolicy")
        if policy == nil {
                if len(rules) == 0 {
                        return allErrs
                } else {
                        allErrs = append(allErrs, field.Required(restartPolicyFld, "must specify restartPolicy when restart rules are used"))
                }
        } else if !supportedContainerRestartPolicies.Has(*policy) {
                allErrs = append(allErrs, field.NotSupported(restartPolicyFld, *policy, sets.List(supportedContainerRestartPolicies)))
        }

        if len(rules) > 20 {
                allErrs = append(allErrs, field.TooLong(fldPath.Child("restartPolicyRules"), rules, 20))
        }
        for i, rule := range rules {
                policyRulesFld := fldPath.Child("restartPolicyRules").Index(i)

                if rule.Action != core.ContainerRestartRuleActionRestart {
                        validActions := []core.ContainerRestartRuleAction{core.ContainerRestartRuleActionRestart}
                        allErrs = append(allErrs, field.NotSupported(policyRulesFld.Child("action"), rule.Action, validActions))
                }

                if rule.ExitCodes != nil {
                        exitCodesFld := policyRulesFld.Child("exitCodes")
                        if !supportedContainerRestartPolicyOperators.Has(rule.ExitCodes.Operator) {
                                allErrs = append(allErrs, field.NotSupported(exitCodesFld.Child("operator"), rule.ExitCodes.Operator, sets.List(supportedContainerRestartPolicyOperators)))
                        }

                        if len(rule.ExitCodes.Values) > 255 {
                                allErrs = append(allErrs, field.TooLong(exitCodesFld.Child("values"), rule.ExitCodes.Values, 255))
                        }
                } else {
                        allErrs = append(allErrs, field.Required(policyRulesFld.Child("exitCodes"), "must be specified"))
                }
        }
        return allErrs
}

// validateEphemeralContainers is called by pod spec and template validation to validate the list of ephemeral containers.
// Note that this is called for pod template even though ephemeral containers aren't allowed in pod templates.
func validateEphemeralContainers(ephemeralContainers []core.EphemeralContainer, containers, initContainers []core.Container, volumes map[string]core.VolumeSource, podClaimNames sets.Set[string], fldPath *field.Path, opts PodValidationOptions, podRestartPolicy *core.RestartPolicy, hostUsers bool) field.ErrorList {
        var allErrs field.ErrorList

        if len(ephemeralContainers) == 0 {
                return allErrs
        }

        otherNames, allNames := sets.Set[string]{}, sets.Set[string]{}
        for _, c := range containers {
                otherNames.Insert(c.Name)
                allNames.Insert(c.Name)
        }
        for _, c := range initContainers {
                otherNames.Insert(c.Name)
                allNames.Insert(c.Name)
        }

        for i, ec := range ephemeralContainers {
                idxPath := fldPath.Index(i)

                c := (*core.Container)(&ec.EphemeralContainerCommon)
                allErrs = append(allErrs, validateContainerCommon(c, volumes, podClaimNames, idxPath, opts, podRestartPolicy, hostUsers)...)
                // Ephemeral containers don't need looser constraints for pod templates, so it's convenient to apply both validations
                // here where we've already converted EphemeralContainerCommon to Container.
                allErrs = append(allErrs, validateContainerOnlyForPod(c, idxPath)...)

                // Ephemeral containers must have a name unique across all container types.
                if allNames.Has(ec.Name) {
                        allErrs = append(allErrs, field.Duplicate(idxPath.Child("name"), ec.Name))
                } else {
                        allNames.Insert(ec.Name)
                }

                // The target container name must exist and be non-ephemeral.
                if ec.TargetContainerName != "" && !otherNames.Has(ec.TargetContainerName) {
                        allErrs = append(allErrs, field.NotFound(idxPath.Child("targetContainerName"), ec.TargetContainerName))
                }

                // Ephemeral containers should not be relied upon for fundamental pod services, so fields such as
                // Lifecycle, probes, resources and ports should be disallowed. This is implemented as a list
                // of allowed fields so that new fields will be given consideration prior to inclusion in ephemeral containers.
                allErrs = append(allErrs, validateFieldAllowList(ec.EphemeralContainerCommon, allowedEphemeralContainerFields, "cannot be set for an Ephemeral Container", idxPath)...)

                // VolumeMount subpaths have the potential to leak resources since they're implemented with bind mounts
                // that aren't cleaned up until the pod exits. Since they also imply that the container is being used
                // as part of the workload, they're disallowed entirely.
                for i, vm := range ec.VolumeMounts {
                        if vm.SubPath != "" {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("volumeMounts").Index(i).Child("subPath"), "cannot be set for an Ephemeral Container"))
                        }
                        if vm.SubPathExpr != "" {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("volumeMounts").Index(i).Child("subPathExpr"), "cannot be set for an Ephemeral Container"))
                        }
                }
        }

        return allErrs
}

// ValidateFieldAcceptList checks that only allowed fields are set.
// The value must be a struct (not a pointer to a struct!).
func validateFieldAllowList(value interface{}, allowedFields map[string]bool, errorText string, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList

        reflectType, reflectValue := reflect.TypeOf(value), reflect.ValueOf(value)
        for i := 0; i < reflectType.NumField(); i++ {
                f := reflectType.Field(i)
                if allowedFields[f.Name] {
                        continue
                }

                // Compare the value of this field to its zero value to determine if it has been set
                if !reflect.DeepEqual(reflectValue.Field(i).Interface(), reflect.Zero(f.Type).Interface()) {
                        r, n := utf8.DecodeRuneInString(f.Name)
                        lcName := string(unicode.ToLower(r)) + f.Name[n:]
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child(lcName), errorText))
                }
        }

        return allErrs
}

// validateInitContainers is called by pod spec and template validation to validate the list of init containers
func validateInitContainers(containers []core.Container, os *core.PodOS, regularContainers []core.Container, volumes map[string]core.VolumeSource, podClaimNames sets.Set[string], gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions, podRestartPolicy *core.RestartPolicy, hostUsers bool) field.ErrorList {
        var allErrs field.ErrorList

        allNames := sets.Set[string]{}
        for _, ctr := range regularContainers {
                allNames.Insert(ctr.Name)
        }
        for i, ctr := range containers {
                idxPath := fldPath.Index(i)

                // Apply the validation common to all container types
                allErrs = append(allErrs, validateContainerCommon(&ctr, volumes, podClaimNames, idxPath, opts, podRestartPolicy, hostUsers)...)

                restartAlways := false
                // Apply the validation specific to init containers
                if ctr.RestartPolicy != nil {
                        allErrs = append(allErrs, validateInitContainerRestartPolicy(ctr.RestartPolicy, ctr.RestartPolicyRules, idxPath, opts)...)
                        restartAlways = *ctr.RestartPolicy == core.ContainerRestartPolicyAlways
                }

                // Names must be unique within regular and init containers. Collisions with ephemeral containers
                // will be detected by validateEphemeralContainers().
                if allNames.Has(ctr.Name) {
                        allErrs = append(allErrs, field.Duplicate(idxPath.Child("name"), ctr.Name))
                } else if len(ctr.Name) > 0 {
                        allNames.Insert(ctr.Name)
                }

                // Check for port conflicts in init containers individually since init containers run one-by-one.
                allErrs = append(allErrs, checkHostPortConflicts([]core.Container{ctr}, fldPath)...)

                switch {
                case restartAlways:
                        if ctr.Lifecycle != nil {
                                allErrs = append(allErrs, validateLifecycle(ctr.Lifecycle, gracePeriod, idxPath.Child("lifecycle"), opts, os)...)
                        }
                        allErrs = append(allErrs, validateLivenessProbe(ctr.LivenessProbe, gracePeriod, idxPath.Child("livenessProbe"), opts)...)
                        allErrs = append(allErrs, validateReadinessProbe(ctr.ReadinessProbe, gracePeriod, idxPath.Child("readinessProbe"), opts)...)
                        allErrs = append(allErrs, validateStartupProbe(ctr.StartupProbe, gracePeriod, idxPath.Child("startupProbe"), opts)...)

                default:
                        // These fields are disallowed for init containers.
                        if ctr.Lifecycle != nil {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("lifecycle"), "may not be set for init containers without restartPolicy=Always"))
                        }
                        if ctr.LivenessProbe != nil {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("livenessProbe"), "may not be set for init containers without restartPolicy=Always"))
                        }
                        if ctr.ReadinessProbe != nil {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("readinessProbe"), "may not be set for init containers without restartPolicy=Always"))
                        }
                        if ctr.StartupProbe != nil {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("startupProbe"), "may not be set for init containers without restartPolicy=Always"))
                        }
                }

                if !opts.AllowSidecarResizePolicy && len(ctr.ResizePolicy) > 0 {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("resizePolicy"), ctr.ResizePolicy, "must not be set for init containers"))
                }
        }

        return allErrs
}

// validateContainerCommon applies validation common to all container types. It's called by regular, init, and ephemeral
// container list validation to require a properly formatted name, image, etc.
func validateContainerCommon(ctr *core.Container, volumes map[string]core.VolumeSource, podClaimNames sets.Set[string], path *field.Path, opts PodValidationOptions, podRestartPolicy *core.RestartPolicy, hostUsers bool) field.ErrorList {
        var allErrs field.ErrorList

        namePath := path.Child("name")
        if len(ctr.Name) == 0 {
                allErrs = append(allErrs, field.Required(namePath, ""))
        } else {
                allErrs = append(allErrs, ValidateDNS1123Label(ctr.Name, namePath)...)
        }

        // TODO: do not validate leading and trailing whitespace to preserve backward compatibility.
        // for example: https://github.com/openshift/origin/issues/14659 image = " " is special token in pod template
        // others may have done similar
        if len(ctr.Image) == 0 {
                allErrs = append(allErrs, field.Required(path.Child("image"), ""))
        }

        switch ctr.TerminationMessagePolicy {
        case core.TerminationMessageReadFile, core.TerminationMessageFallbackToLogsOnError:
        case "":
                allErrs = append(allErrs, field.Required(path.Child("terminationMessagePolicy"), ""))
        default:
                supported := []core.TerminationMessagePolicy{
                        core.TerminationMessageReadFile,
                        core.TerminationMessageFallbackToLogsOnError,
                }
                allErrs = append(allErrs, field.NotSupported(path.Child("terminationMessagePolicy"), ctr.TerminationMessagePolicy, supported))
        }

        volMounts := GetVolumeMountMap(ctr.VolumeMounts)
        volDevices := GetVolumeDeviceMap(ctr.VolumeDevices)
        allErrs = append(allErrs, validateContainerPorts(ctr.Ports, path.Child("ports"))...)
        allErrs = append(allErrs, ValidateEnv(ctr.Env, path.Child("env"), opts)...)
        allErrs = append(allErrs, ValidateEnvFrom(ctr.EnvFrom, path.Child("envFrom"), opts)...)
        allErrs = append(allErrs, ValidateVolumeMounts(ctr.VolumeMounts, volDevices, volumes, ctr, path.Child("volumeMounts"), opts)...)
        allErrs = append(allErrs, ValidateVolumeDevices(ctr.VolumeDevices, volMounts, volumes, path.Child("volumeDevices"))...)
        allErrs = append(allErrs, validatePullPolicy(ctr.ImagePullPolicy, path.Child("imagePullPolicy"))...)
        allErrs = append(allErrs, ValidateContainerResourceRequirements(&ctr.Resources, podClaimNames, path.Child("resources"), opts)...)
        allErrs = append(allErrs, validateResizePolicy(ctr.ResizePolicy, path.Child("resizePolicy"), podRestartPolicy)...)
        allErrs = append(allErrs, ValidateSecurityContext(ctr.SecurityContext, path.Child("securityContext"), hostUsers)...)
        return allErrs
}

func validateHostUsers(spec *core.PodSpec, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        // Only make the following checks if hostUsers is false (otherwise, the container uses the
        // same userns as the host, and so there isn't anything to check).
        if spec.SecurityContext == nil || spec.SecurityContext.HostUsers == nil || *spec.SecurityContext.HostUsers {
                return allErrs
        }

        // We decided to restrict the usage of userns with other host namespaces:
        //         https://github.com/kubernetes/kubernetes/pull/111090#discussion_r935994282
        // The tl;dr is: you can easily run into permission issues that seem unexpected, we don't
        // know of any good use case and we can always enable them later.

        // Note we already validated above spec.SecurityContext is not nil.
        if spec.SecurityContext.HostNetwork {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostNetwork"), "when `hostUsers` is false"))
        }
        if spec.SecurityContext.HostPID {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("HostPID"), "when `hostUsers` is false"))
        }
        if spec.SecurityContext.HostIPC {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("HostIPC"), "when `hostUsers` is false"))
        }
        if !opts.AllowUserNamespacesWithVolumeDevices {
                // volumeDevices won't work, as they don't support idmap mounts nor we are chown-ing them.
                // Let's return a clear error in this case.
                podshelper.VisitContainersWithPath(spec, fldPath, func(c *core.Container, containerPath *field.Path) bool {
                        if len(c.VolumeDevices) > 0 {
                                allErrs = append(allErrs, field.Forbidden(containerPath.Child("volumeDevices"), "when `hostUsers` is false"))
                        }
                        return true // Always visit all containers.
                })
        }

        return allErrs
}

// validateFileKeyRefVolumes validates that volumes referenced by FileKeyRef environment variables
// are of type emptyDir. FileKeyRef requires emptyDir volumes to ensure proper file access.
func validateFileKeyRefVolumes(spec *core.PodSpec, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        volumeSources := make(map[string]*core.VolumeSource)
        for i := range spec.Volumes {
                volume := &spec.Volumes[i]
                volumeSources[volume.Name] = &volume.VolumeSource
        }

        podshelper.VisitContainersWithPath(spec, fldPath, func(c *core.Container, cFldPath *field.Path) bool {
                envPath := cFldPath.Child("env")
                for j, env := range c.Env {
                        // Only care about environment variables that use FileKeyRef.
                        if env.ValueFrom == nil || env.ValueFrom.FileKeyRef == nil {
                                continue
                        }

                        volumeName := env.ValueFrom.FileKeyRef.VolumeName
                        fileKeyRefPath := envPath.Index(j).Child("valueFrom").Child("fileKeyRef")
                        volumeNamePath := fileKeyRefPath.Child("volumeName")

                        source, found := volumeSources[volumeName]
                        if !found {
                                // The referenced volume does not exist in the pod spec.
                                allErrs = append(allErrs, field.NotFound(volumeNamePath, volumeName))
                        } else if source.EmptyDir == nil {
                                // The volume exists, but it is not of type emptyDir, which is required.
                                allErrs = append(allErrs, field.Invalid(volumeNamePath, volumeName, "referenced volume must be of type emptyDir"))
                        }
                }

                return true
        })

        return allErrs
}

func validatePodHostName(spec *core.PodSpec, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if spec.HostnameOverride == nil {
                return allErrs
        }

        // If SetHostnameAsFQDN is true, HostnameOverride must not be set.
        if spec.SetHostnameAsFQDN != nil && *spec.SetHostnameAsFQDN {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostnameOverride"), "may not be specified when setHostnameAsFQDN is true"))
        }
        // If HostNetwork is true, HostnameOverride must not be set.
        if spec.SecurityContext != nil && spec.SecurityContext.HostNetwork {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostnameOverride"), "may not be specified when hostNetwork is true"))
        }
        if len(*spec.HostnameOverride) > 64 {
                allErrs = append(allErrs, field.TooLong(fldPath.Child("hostnameOverride"), "" /*unused*/, 64))
        }

        // Not allow to set a string that is not an RFC 1123 DNS subdomain as a hostname.
        allErrs = append(allErrs, ValidateDNS1123Subdomain(*spec.HostnameOverride, fldPath.Child("hostnameOverride"))...)

        return allErrs
}

// validateContainers is called by pod spec and template validation to validate the list of regular containers.
func validateContainers(containers []core.Container, os *core.PodOS, volumes map[string]core.VolumeSource, podClaimNames sets.Set[string], gracePeriod *int64, fldPath *field.Path, opts PodValidationOptions, podRestartPolicy *core.RestartPolicy, hostUsers bool) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(containers) == 0 {
                return append(allErrs, field.Required(fldPath, ""))
        }

        allNames := sets.Set[string]{}
        for i, ctr := range containers {
                path := fldPath.Index(i)

                // Apply validation common to all containers
                allErrs = append(allErrs, validateContainerCommon(&ctr, volumes, podClaimNames, path, opts, podRestartPolicy, hostUsers)...)

                // Container names must be unique within the list of regular containers.
                // Collisions with init or ephemeral container names will be detected by the init or ephemeral
                // container validation to prevent duplicate error messages.
                if allNames.Has(ctr.Name) {
                        allErrs = append(allErrs, field.Duplicate(path.Child("name"), ctr.Name))
                } else {
                        allNames.Insert(ctr.Name)
                }

                // These fields are allowed for regular containers and restartable init
                // containers.
                // Regular init container and ephemeral container validation will return
                // field.Forbidden() for these paths.
                if ctr.Lifecycle != nil {
                        allErrs = append(allErrs, validateLifecycle(ctr.Lifecycle, gracePeriod, path.Child("lifecycle"), opts, os)...)
                }
                allErrs = append(allErrs, validateLivenessProbe(ctr.LivenessProbe, gracePeriod, path.Child("livenessProbe"), opts)...)
                allErrs = append(allErrs, validateReadinessProbe(ctr.ReadinessProbe, gracePeriod, path.Child("readinessProbe"), opts)...)
                allErrs = append(allErrs, validateStartupProbe(ctr.StartupProbe, gracePeriod, path.Child("startupProbe"), opts)...)

                if opts.AllowContainerRestartPolicyRules {
                        allErrs = append(allErrs, validateContainerRestartPolicy(ctr.RestartPolicy, ctr.RestartPolicyRules, path)...)
                } else if ctr.RestartPolicy != nil {
                        allErrs = append(allErrs, field.Forbidden(path.Child("restartPolicy"), "may not be set for non-init containers"))
                }
        }

        // Port conflicts are checked across all containers
        allErrs = append(allErrs, checkHostPortConflicts(containers, fldPath)...)

        return allErrs
}

func validateRestartPolicy(restartPolicy *core.RestartPolicy, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        switch *restartPolicy {
        case core.RestartPolicyAlways, core.RestartPolicyOnFailure, core.RestartPolicyNever:
                break
        case "":
                allErrors = append(allErrors, field.Required(fldPath, ""))
        default:
                validValues := []core.RestartPolicy{core.RestartPolicyAlways, core.RestartPolicyOnFailure, core.RestartPolicyNever}
                allErrors = append(allErrors, field.NotSupported(fldPath, *restartPolicy, validValues))
        }

        return allErrors
}

func ValidatePreemptionPolicy(preemptionPolicy *core.PreemptionPolicy, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        switch *preemptionPolicy {
        case core.PreemptLowerPriority, core.PreemptNever:
        case "":
                allErrors = append(allErrors, field.Required(fldPath, ""))
        default:
                validValues := []core.PreemptionPolicy{core.PreemptLowerPriority, core.PreemptNever}
                allErrors = append(allErrors, field.NotSupported(fldPath, preemptionPolicy, validValues))
        }
        return allErrors
}

func validateDNSPolicy(dnsPolicy *core.DNSPolicy, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        switch *dnsPolicy {
        case core.DNSClusterFirstWithHostNet, core.DNSClusterFirst, core.DNSDefault, core.DNSNone:
        case "":
                allErrors = append(allErrors, field.Required(fldPath, ""))
        default:
                validValues := []core.DNSPolicy{core.DNSClusterFirstWithHostNet, core.DNSClusterFirst, core.DNSDefault, core.DNSNone}
                allErrors = append(allErrors, field.NotSupported(fldPath, dnsPolicy, validValues))
        }
        return allErrors
}

var validFSGroupChangePolicies = sets.New(core.FSGroupChangeOnRootMismatch, core.FSGroupChangeAlways)

func validateFSGroupChangePolicy(fsGroupPolicy *core.PodFSGroupChangePolicy, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        if !validFSGroupChangePolicies.Has(*fsGroupPolicy) {
                allErrors = append(allErrors, field.NotSupported(fldPath, fsGroupPolicy, sets.List(validFSGroupChangePolicies)))
        }
        return allErrors
}

const (
        // Limits on various DNS parameters. These are derived from
        // restrictions in Linux libc name resolution handling.
        // Max number of DNS name servers.
        MaxDNSNameservers = 3
        // Max number of domains in the search path list.
        MaxDNSSearchPaths = 32
        // Max number of characters in the search path.
        MaxDNSSearchListChars = 2048
)

func validateReadinessGates(readinessGates []core.PodReadinessGate, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for i, value := range readinessGates {
                allErrs = append(allErrs, ValidateQualifiedName(string(value.ConditionType), fldPath.Index(i).Child("conditionType"))...)
        }
        return allErrs
}

func validateSchedulingGates(schedulingGates []core.PodSchedulingGate, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        // There should be no duplicates in the list of scheduling gates.
        seen := sets.Set[string]{}
        for i, schedulingGate := range schedulingGates {
                allErrs = append(allErrs, ValidateQualifiedName(schedulingGate.Name, fldPath.Index(i))...)
                if seen.Has(schedulingGate.Name) {
                        allErrs = append(allErrs, field.Duplicate(fldPath.Index(i), schedulingGate.Name))
                }
                seen.Insert(schedulingGate.Name)
        }
        return allErrs
}

func validatePodDNSConfig(dnsConfig *core.PodDNSConfig, dnsPolicy *core.DNSPolicy, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        // Validate DNSNone case. Must provide at least one DNS name server.
        if dnsPolicy != nil && *dnsPolicy == core.DNSNone {
                if dnsConfig == nil {
                        return append(allErrs, field.Required(fldPath, fmt.Sprintf("must provide `dnsConfig` when `dnsPolicy` is %s", core.DNSNone)))
                }
                if len(dnsConfig.Nameservers) == 0 {
                        return append(allErrs, field.Required(fldPath.Child("nameservers"), fmt.Sprintf("must provide at least one DNS nameserver when `dnsPolicy` is %s", core.DNSNone)))
                }
        }

        if dnsConfig != nil {
                // Validate nameservers.
                if len(dnsConfig.Nameservers) > MaxDNSNameservers {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("nameservers"), dnsConfig.Nameservers, fmt.Sprintf("must not have more than %v nameservers", MaxDNSNameservers)))
                }
                for i, ns := range dnsConfig.Nameservers {
                        allErrs = append(allErrs, IsValidIPForLegacyField(fldPath.Child("nameservers").Index(i), ns, nil)...)
                }
                // Validate searches.
                if len(dnsConfig.Searches) > MaxDNSSearchPaths {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("searches"), dnsConfig.Searches, fmt.Sprintf("must not have more than %v search paths", MaxDNSSearchPaths)))
                }
                // Include the space between search paths.
                if len(strings.Join(dnsConfig.Searches, " ")) > MaxDNSSearchListChars {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("searches"), dnsConfig.Searches, fmt.Sprintf("must not have more than %v characters (including spaces) in the search list", MaxDNSSearchListChars)))
                }

                for i, search := range dnsConfig.Searches {
                        if opts.AllowRelaxedDNSSearchValidation {
                                if search != "." {
                                        search = strings.TrimSuffix(search, ".")
                                        allErrs = append(allErrs, ValidateDNS1123SubdomainWithUnderScore(search, fldPath.Child("searches").Index(i))...)
                                }
                        } else {
                                search = strings.TrimSuffix(search, ".")
                                allErrs = append(allErrs, ValidateDNS1123Subdomain(search, fldPath.Child("searches").Index(i))...)
                        }

                }
                // Validate options.
                for i, option := range dnsConfig.Options {
                        if len(option.Name) == 0 {
                                allErrs = append(allErrs, field.Required(fldPath.Child("options").Index(i), "must not be empty"))
                        }
                }
        }
        return allErrs
}

// validatePodHostNetworkDeps checks fields which depend on whether HostNetwork is
// true or not.  It should be called on all PodSpecs, but opts can change what
// is enforce.  E.g. opts.ResourceIsPod should only be set when called in the
// context of a Pod, and not on PodSpecs which are embedded in other resources
// (e.g. Deployments).
func validatePodHostNetworkDeps(spec *core.PodSpec, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        // For <reasons> we keep `.HostNetwork` in .SecurityContext on the internal
        // version of Pod.
        hostNetwork := false
        if spec.SecurityContext != nil {
                hostNetwork = spec.SecurityContext.HostNetwork
        }

        allErrors := field.ErrorList{}

        if hostNetwork {
                fldPath := fldPath.Child("containers")
                for i, container := range spec.Containers {
                        portsPath := fldPath.Index(i).Child("ports")
                        for i, port := range container.Ports {
                                idxPath := portsPath.Index(i)
                                // At this point, we know that HostNetwork is true. If this
                                // PodSpec is in a Pod (opts.ResourceIsPod), then HostPort must
                                // be the same value as ContainerPort. If this PodSpec is in
                                // some other resource (e.g. Deployment) we allow 0 (i.e.
                                // unspecified) because it will be defaulted when the Pod is
                                // ultimately created, but we do not allow any other values.
                                if hp, cp := port.HostPort, port.ContainerPort; (opts.ResourceIsPod || hp != 0) && hp != cp {
                                        allErrors = append(allErrors, field.Invalid(idxPath.Child("hostPort"), port.HostPort, "must match `containerPort` when `hostNetwork` is true"))
                                }
                        }
                }
        }
        return allErrors
}

// validateImagePullSecrets checks to make sure the pull secrets are well
// formed.  Right now, we only expect name to be set (it's the only field).  If
// this ever changes and someone decides to set those fields, we'd like to
// know.
func validateImagePullSecrets(imagePullSecrets []core.LocalObjectReference, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        for i, currPullSecret := range imagePullSecrets {
                idxPath := fldPath.Index(i)
                strippedRef := core.LocalObjectReference{Name: currPullSecret.Name}
                if !reflect.DeepEqual(strippedRef, currPullSecret) {
                        allErrors = append(allErrors, field.Invalid(idxPath, currPullSecret, "only name may be set"))
                }
        }
        return allErrors
}

// validateAffinity checks if given affinities are valid
func validateAffinity(affinity *core.Affinity, opts PodValidationOptions, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if affinity != nil {
                if affinity.NodeAffinity != nil {
                        allErrs = append(allErrs, validateNodeAffinity(affinity.NodeAffinity, opts, fldPath.Child("nodeAffinity"))...)
                }
                if affinity.PodAffinity != nil {
                        allErrs = append(allErrs, validatePodAffinity(affinity.PodAffinity, opts.AllowInvalidLabelValueInSelector, fldPath.Child("podAffinity"))...)
                }
                if affinity.PodAntiAffinity != nil {
                        allErrs = append(allErrs, validatePodAntiAffinity(affinity.PodAntiAffinity, opts.AllowInvalidLabelValueInSelector, fldPath.Child("podAntiAffinity"))...)
                }
        }

        return allErrs
}

func validateTaintEffect(effect *core.TaintEffect, allowEmpty bool, fldPath *field.Path) field.ErrorList {
        if !allowEmpty && len(*effect) == 0 {
                return field.ErrorList{field.Required(fldPath, "")}
        }

        allErrors := field.ErrorList{}
        switch *effect {
        // TODO: Replace next line with subsequent commented-out line when implement TaintEffectNoScheduleNoAdmit.
        case core.TaintEffectNoSchedule, core.TaintEffectPreferNoSchedule, core.TaintEffectNoExecute:
                // case core.TaintEffectNoSchedule, core.TaintEffectPreferNoSchedule, core.TaintEffectNoScheduleNoAdmit, core.TaintEffectNoExecute:
        default:
                validValues := []core.TaintEffect{
                        core.TaintEffectNoSchedule,
                        core.TaintEffectPreferNoSchedule,
                        core.TaintEffectNoExecute,
                        // TODO: Uncomment this block when implement TaintEffectNoScheduleNoAdmit.
                        // core.TaintEffectNoScheduleNoAdmit,
                }
                allErrors = append(allErrors, field.NotSupported(fldPath, *effect, validValues))
        }
        return allErrors
}

// validateOnlyAddedTolerations validates updated pod tolerations.
func validateOnlyAddedTolerations(newTolerations []core.Toleration, oldTolerations []core.Toleration, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, old := range oldTolerations {
                found := false
                oldTolerationClone := old.DeepCopy()
                for _, newToleration := range newTolerations {
                        // assign to our clone before doing a deep equal so we can allow tolerationseconds to change.
                        oldTolerationClone.TolerationSeconds = newToleration.TolerationSeconds // +k8s:verify-mutation:reason=clone
                        if reflect.DeepEqual(*oldTolerationClone, newToleration) {
                                found = true
                                break
                        }
                }
                if !found {
                        allErrs = append(allErrs, field.Forbidden(fldPath, "existing toleration can not be modified except its tolerationSeconds"))
                        return allErrs
                }
        }

        allErrs = append(allErrs, ValidateTolerations(newTolerations, fldPath)...)
        return allErrs
}

func validateOnlyDeletedSchedulingGates(newGates, oldGates []core.PodSchedulingGate, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(newGates) == 0 {
                return allErrs
        }

        additionalGates := make(map[string]int)
        for i, newGate := range newGates {
                additionalGates[newGate.Name] = i
        }

        for _, oldGate := range oldGates {
                delete(additionalGates, oldGate.Name)
        }

        for gate, i := range additionalGates {
                allErrs = append(allErrs, field.Forbidden(fldPath.Index(i).Child("name"), fmt.Sprintf("only deletion is allowed, but found new scheduling gate '%s'", gate)))
        }

        return allErrs
}

func ValidateHostAliases(hostAliases []core.HostAlias, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for i, hostAlias := range hostAliases {
                allErrs = append(allErrs, IsValidIPForLegacyField(fldPath.Index(i).Child("ip"), hostAlias.IP, nil)...)
                for j, hostname := range hostAlias.Hostnames {
                        allErrs = append(allErrs, ValidateDNS1123Subdomain(hostname, fldPath.Index(i).Child("hostnames").Index(j))...)
                }
        }
        return allErrs
}

// ValidateTolerations tests if given tolerations have valid data.
func ValidateTolerations(tolerations []core.Toleration, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        for i, toleration := range tolerations {
                idxPath := fldPath.Index(i)
                // validate the toleration key
                if len(toleration.Key) > 0 {
                        allErrors = append(allErrors, unversionedvalidation.ValidateLabelName(toleration.Key, idxPath.Child("key"))...)
                }

                // empty toleration key with Exists operator and empty value means match all taints
                if len(toleration.Key) == 0 && toleration.Operator != core.TolerationOpExists {
                        allErrors = append(allErrors, field.Invalid(idxPath.Child("operator"), toleration.Operator,
                                "operator must be Exists when `key` is empty, which means \"match all values and all keys\""))
                }

                if toleration.TolerationSeconds != nil && toleration.Effect != core.TaintEffectNoExecute {
                        allErrors = append(allErrors, field.Invalid(idxPath.Child("effect"), toleration.Effect,
                                "effect must be 'NoExecute' when `tolerationSeconds` is set"))
                }

                // validate toleration operator and value
                switch toleration.Operator {
                // empty operator means Equal
                case core.TolerationOpEqual, "":
                        if errs := validation.IsValidLabelValue(toleration.Value); len(errs) != 0 {
                                allErrors = append(allErrors, field.Invalid(idxPath.Child("operator"), toleration.Value, strings.Join(errs, ";")))
                        }
                case core.TolerationOpExists:
                        if len(toleration.Value) > 0 {
                                allErrors = append(allErrors, field.Invalid(idxPath.Child("operator"), toleration.Value, "value must be empty when `operator` is 'Exists'"))
                        }
                default:
                        validValues := []core.TolerationOperator{core.TolerationOpEqual, core.TolerationOpExists}
                        allErrors = append(allErrors, field.NotSupported(idxPath.Child("operator"), toleration.Operator, validValues))
                }

                // validate toleration effect, empty toleration effect means match all taint effects
                if len(toleration.Effect) > 0 {
                        allErrors = append(allErrors, validateTaintEffect(&toleration.Effect, true, idxPath.Child("effect"))...)
                }
        }
        return allErrors
}

// validateContainersOnlyForPod does additional validation for containers on a pod versus a pod template
// it only does additive validation of fields not covered in validateContainers and is not called for
// ephemeral containers which require a conversion to core.Container.
func validateContainersOnlyForPod(containers []core.Container, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for i, ctr := range containers {
                allErrs = append(allErrs, validateContainerOnlyForPod(&ctr, fldPath.Index(i))...)
        }
        return allErrs
}

// validateContainerOnlyForPod does pod-only (i.e. not pod template) validation for a single container.
// This is called by validateContainersOnlyForPod and validateEphemeralContainers directly.
func validateContainerOnlyForPod(ctr *core.Container, path *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(ctr.Image) != len(strings.TrimSpace(ctr.Image)) {
                allErrs = append(allErrs, field.Invalid(path.Child("image"), ctr.Image, "must not have leading or trailing whitespace"))
        }
        return allErrs
}

// PodValidationOptions contains the different settings for pod validation
type PodValidationOptions struct {
        // Allow invalid pod-deletion-cost annotation value for backward compatibility.
        AllowInvalidPodDeletionCost bool
        // Allow invalid label-value in LabelSelector
        AllowInvalidLabelValueInSelector bool
        // Allow pod spec to use non-integer multiple of huge page unit size
        AllowIndivisibleHugePagesValues bool
        // Allow invalid topologySpreadConstraint labelSelector for backward compatibility
        AllowInvalidTopologySpreadConstraintLabelSelector bool
        // Allow projected token volumes with non-local paths
        AllowNonLocalProjectedTokenPath bool
        // Allow namespaced sysctls in hostNet and hostIPC pods
        AllowNamespacedSysctlsForHostNetAndHostIPC bool
        // The top-level resource being validated is a Pod, not just a PodSpec
        // embedded in some other resource.
        ResourceIsPod bool
        // Allow relaxed validation of environment variable names
        AllowRelaxedEnvironmentVariableValidation bool
        // Allow the use of a relaxed DNS search
        AllowRelaxedDNSSearchValidation bool
        // Allows zero value for Pod Lifecycle Sleep Action
        AllowPodLifecycleSleepActionZeroValue bool
        // Allow only Recursive value of SELinuxChangePolicy.
        AllowOnlyRecursiveSELinuxChangePolicy bool
        // Indicates whether PodLevelResources feature is enabled or disabled.
        PodLevelResourcesEnabled bool
        // Allow sidecar containers resize policy for backward compatibility
        AllowSidecarResizePolicy bool
        // Allow invalid label-value in RequiredNodeSelector
        AllowInvalidLabelValueInRequiredNodeAffinity bool
        // Allow feature of MatchLabelKeys in TopologySpreadConstraints
        AllowMatchLabelKeysInPodTopologySpread bool
        // Allow merging selectors built from MatchLabelKeys into LabelSelector of TopologySpreadConstraints
        AllowMatchLabelKeysInPodTopologySpreadSelectorMerge bool
        // OldPod has invalid MatchLabelKeys in TopologySpreadConstraints against current(>=v1.34) validation
        OldPodViolatesMatchLabelKeysValidation bool
        // OldPod has invalid MatchLabelKeys in TopologySpreadConstraints against legacy(<v1.34) validation
        OldPodViolatesLegacyMatchLabelKeysValidation bool
        // Allows containers to consume environment variables via environment variable files.
        AllowEnvFilesValidation bool
        // Allows containers have restart policy and restart policy rules.
        AllowContainerRestartPolicyRules bool
        // Allow user namespaces with volume devices, even though they will not function properly (should only be tolerated in updates of objects which already have this invalid configuration).
        AllowUserNamespacesWithVolumeDevices bool
}

// validatePodMetadataAndSpec tests if required fields in the pod.metadata and pod.spec are set,
// and is called by ValidatePodCreate and ValidatePodUpdate.
func validatePodMetadataAndSpec(pod *core.Pod, opts PodValidationOptions) field.ErrorList {
        metaPath := field.NewPath("metadata")
        specPath := field.NewPath("spec")

        allErrs := ValidateObjectMeta(&pod.ObjectMeta, true, ValidatePodName, metaPath)
        allErrs = append(allErrs, ValidatePodSpecificAnnotations(pod.ObjectMeta.Annotations, &pod.Spec, metaPath.Child("annotations"), opts)...)
        allErrs = append(allErrs, ValidatePodSpec(&pod.Spec, &pod.ObjectMeta, specPath, opts)...)

        // we do additional validation only pertinent for pods and not pod templates
        // this was done to preserve backwards compatibility

        if pod.Spec.ServiceAccountName == "" {
                for vi, volume := range pod.Spec.Volumes {
                        path := specPath.Child("volumes").Index(vi).Child("projected")
                        if volume.Projected != nil {
                                for si, source := range volume.Projected.Sources {
                                        saPath := path.Child("sources").Index(si).Child("serviceAccountToken")
                                        if source.ServiceAccountToken != nil {
                                                allErrs = append(allErrs, field.Forbidden(saPath, "must not be specified when serviceAccountName is not set"))
                                        }
                                }
                        }
                }
        }

        allErrs = append(allErrs, validateContainersOnlyForPod(pod.Spec.Containers, specPath.Child("containers"))...)
        allErrs = append(allErrs, validateContainersOnlyForPod(pod.Spec.InitContainers, specPath.Child("initContainers"))...)
        // validateContainersOnlyForPod() is checked for ephemeral containers by validateEphemeralContainers()

        return allErrs
}

// validatePodIPs validates IPs in pod status
func validatePodIPs(pod, oldPod *core.Pod) field.ErrorList {
        allErrs := field.ErrorList{}

        podIPsField := field.NewPath("status", "podIPs")

        // all new PodIPs must be valid IPs, but existing invalid ones can be kept.
        var existingPodIPs []string
        if oldPod != nil {
                existingPodIPs = make([]string, len(oldPod.Status.PodIPs))
                for i, podIP := range oldPod.Status.PodIPs {
                        existingPodIPs[i] = podIP.IP
                }
        }
        for i, podIP := range pod.Status.PodIPs {
                allErrs = append(allErrs, IsValidIPForLegacyField(podIPsField.Index(i), podIP.IP, existingPodIPs)...)
        }

        // if we have more than one Pod.PodIP then we must have a dual-stack pair
        if len(pod.Status.PodIPs) > 1 {
                podIPs := make([]string, 0, len(pod.Status.PodIPs))
                for _, podIP := range pod.Status.PodIPs {
                        podIPs = append(podIPs, podIP.IP)
                }

                dualStack, err := netutils.IsDualStackIPStrings(podIPs)
                if err != nil {
                        allErrs = append(allErrs, field.InternalError(podIPsField, fmt.Errorf("failed to check for dual stack with error:%v", err)))
                }

                // We only support one from each IP family (i.e. max two IPs in this list).
                if !dualStack || len(podIPs) > 2 {
                        allErrs = append(allErrs, field.Invalid(podIPsField, pod.Status.PodIPs, "may specify no more than one IP for each IP family"))
                }
        }

        return allErrs
}

// validateHostIPs validates IPs in pod status
func validateHostIPs(pod, oldPod *core.Pod) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(pod.Status.HostIPs) == 0 {
                return allErrs
        }

        hostIPsField := field.NewPath("status", "hostIPs")

        // hostIP must be equal to hostIPs[0].IP
        if pod.Status.HostIP != pod.Status.HostIPs[0].IP {
                allErrs = append(allErrs, field.Invalid(hostIPsField.Index(0).Child("ip"), pod.Status.HostIPs[0].IP, "must be equal to `hostIP`"))
        }

        // all new HostIPs must be valid IPs, but existing invalid ones can be kept.
        var existingHostIPs []string
        if oldPod != nil {
                existingHostIPs = make([]string, len(oldPod.Status.HostIPs))
                for i, hostIP := range oldPod.Status.HostIPs {
                        existingHostIPs[i] = hostIP.IP
                }
        }
        for i, hostIP := range pod.Status.HostIPs {
                allErrs = append(allErrs, IsValidIPForLegacyField(hostIPsField.Index(i), hostIP.IP, existingHostIPs)...)
        }

        // if we have more than one Pod.HostIP then we must have a dual-stack pair
        if len(pod.Status.HostIPs) > 1 {
                hostIPs := make([]string, 0, len(pod.Status.HostIPs))
                for _, hostIP := range pod.Status.HostIPs {
                        hostIPs = append(hostIPs, hostIP.IP)
                }

                dualStack, err := netutils.IsDualStackIPStrings(hostIPs)
                if err != nil {
                        allErrs = append(allErrs, field.InternalError(hostIPsField, fmt.Errorf("failed to check for dual stack with error:%v", err)))
                }

                // We only support one from each IP family (i.e. max two IPs in this list).
                if !dualStack || len(hostIPs) > 2 {
                        allErrs = append(allErrs, field.Invalid(hostIPsField, pod.Status.HostIPs, "may specify no more than one IP for each IP family"))
                }
        }

        return allErrs
}

// ValidatePodSpec tests that the specified PodSpec has valid data.
// This includes checking formatting and uniqueness.  It also canonicalizes the
// structure by setting default values and implementing any backwards-compatibility
// tricks.
// The pod metadata is needed to validate generic ephemeral volumes. It is optional
// and should be left empty unless the spec is from a real pod object.
func ValidatePodSpec(spec *core.PodSpec, podMeta *metav1.ObjectMeta, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if spec.TerminationGracePeriodSeconds == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("terminationGracePeriodSeconds"), ""))
        }
        gracePeriod := spec.TerminationGracePeriodSeconds

        // The default for hostUsers is true, so a spec with no SecurityContext or no HostUsers field will be true.
        // If the default ever changes, this condition will need to be changed.
        hostUsers := spec.SecurityContext == nil || spec.SecurityContext.HostUsers == nil || *spec.SecurityContext.HostUsers

        vols, vErrs := ValidateVolumes(spec.Volumes, podMeta, fldPath.Child("volumes"), opts)
        allErrs = append(allErrs, vErrs...)
        podClaimNames := gatherPodResourceClaimNames(spec.ResourceClaims)
        allErrs = append(allErrs, validatePodResourceClaims(podMeta, spec.ResourceClaims, fldPath.Child("resourceClaims"))...)
        allErrs = append(allErrs, validateContainers(spec.Containers, spec.OS, vols, podClaimNames, gracePeriod, fldPath.Child("containers"), opts, &spec.RestartPolicy, hostUsers)...)
        allErrs = append(allErrs, validateInitContainers(spec.InitContainers, spec.OS, spec.Containers, vols, podClaimNames, gracePeriod, fldPath.Child("initContainers"), opts, &spec.RestartPolicy, hostUsers)...)
        allErrs = append(allErrs, validateEphemeralContainers(spec.EphemeralContainers, spec.Containers, spec.InitContainers, vols, podClaimNames, fldPath.Child("ephemeralContainers"), opts, &spec.RestartPolicy, hostUsers)...)

        if opts.PodLevelResourcesEnabled {
                allErrs = append(allErrs, validatePodResources(spec, podClaimNames, fldPath, opts)...)
        }

        allErrs = append(allErrs, validatePodHostNetworkDeps(spec, fldPath, opts)...)
        allErrs = append(allErrs, validateRestartPolicy(&spec.RestartPolicy, fldPath.Child("restartPolicy"))...)
        allErrs = append(allErrs, validateDNSPolicy(&spec.DNSPolicy, fldPath.Child("dnsPolicy"))...)
        allErrs = append(allErrs, unversionedvalidation.ValidateLabels(spec.NodeSelector, fldPath.Child("nodeSelector"))...)
        allErrs = append(allErrs, validatePodSpecSecurityContext(spec.SecurityContext, spec, fldPath, fldPath.Child("securityContext"), opts)...)
        allErrs = append(allErrs, validateImagePullSecrets(spec.ImagePullSecrets, fldPath.Child("imagePullSecrets"))...)
        allErrs = append(allErrs, validateAffinity(spec.Affinity, opts, fldPath.Child("affinity"))...)
        allErrs = append(allErrs, validatePodDNSConfig(spec.DNSConfig, &spec.DNSPolicy, fldPath.Child("dnsConfig"), opts)...)
        allErrs = append(allErrs, validateReadinessGates(spec.ReadinessGates, fldPath.Child("readinessGates"))...)
        allErrs = append(allErrs, validateSchedulingGates(spec.SchedulingGates, fldPath.Child("schedulingGates"))...)
        allErrs = append(allErrs, validateTopologySpreadConstraints(spec.TopologySpreadConstraints, fldPath.Child("topologySpreadConstraints"), opts)...)
        allErrs = append(allErrs, validateWindowsHostProcessPod(spec, fldPath)...)
        allErrs = append(allErrs, validateHostUsers(spec, fldPath, opts)...)
        allErrs = append(allErrs, validatePodHostName(spec, fldPath)...)
        if len(spec.ServiceAccountName) > 0 {
                for _, msg := range ValidateServiceAccountName(spec.ServiceAccountName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("serviceAccountName"), spec.ServiceAccountName, msg))
                }
        }

        if len(spec.NodeName) > 0 {
                for _, msg := range ValidateNodeName(spec.NodeName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("nodeName"), spec.NodeName, msg))
                }
        }

        if spec.ActiveDeadlineSeconds != nil {
                value := *spec.ActiveDeadlineSeconds
                if value < 1 || value > math.MaxInt32 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("activeDeadlineSeconds"), value, validation.InclusiveRangeError(1, math.MaxInt32)))
                }
        }

        if len(spec.Hostname) > 0 {
                allErrs = append(allErrs, ValidateDNS1123Label(spec.Hostname, fldPath.Child("hostname"))...)
        }

        if len(spec.Subdomain) > 0 {
                allErrs = append(allErrs, ValidateDNS1123Label(spec.Subdomain, fldPath.Child("subdomain"))...)
        }

        if len(spec.Tolerations) > 0 {
                allErrs = append(allErrs, ValidateTolerations(spec.Tolerations, fldPath.Child("tolerations"))...)
        }

        if len(spec.HostAliases) > 0 {
                allErrs = append(allErrs, ValidateHostAliases(spec.HostAliases, fldPath.Child("hostAliases"))...)
        }

        if len(spec.PriorityClassName) > 0 {
                for _, msg := range ValidatePriorityClassName(spec.PriorityClassName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("priorityClassName"), spec.PriorityClassName, msg))
                }
        }

        if spec.RuntimeClassName != nil {
                allErrs = append(allErrs, ValidateRuntimeClassName(*spec.RuntimeClassName, fldPath.Child("runtimeClassName"))...)
        }

        if spec.PreemptionPolicy != nil {
                allErrs = append(allErrs, ValidatePreemptionPolicy(spec.PreemptionPolicy, fldPath.Child("preemptionPolicy"))...)
        }

        if spec.Overhead != nil {
                allErrs = append(allErrs, validateOverhead(spec.Overhead, fldPath.Child("overhead"), opts)...)
        }

        if spec.OS != nil {
                osErrs := validateOS(spec, fldPath.Child("os"), opts)
                switch {
                case len(osErrs) > 0:
                        allErrs = append(allErrs, osErrs...)
                case spec.OS.Name == core.Linux:
                        allErrs = append(allErrs, validateLinux(spec, fldPath)...)
                case spec.OS.Name == core.Windows:
                        allErrs = append(allErrs, validateWindows(spec, fldPath)...)
                }
        }

        allErrs = append(allErrs, validateFileKeyRefVolumes(spec, fldPath)...)
        return allErrs
}

func validatePodResources(spec *core.PodSpec, podClaimNames sets.Set[string], fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        if spec.Resources == nil {
                return nil
        }
        resourcesFldPath := fldPath.Child("resources")
        if spec.OS != nil && spec.OS.Name == core.Windows {
                // Do not include more detailed errors on the resources field value
                // if the resources field may not be set on the target OS.
                return field.ErrorList{
                        field.Forbidden(resourcesFldPath, "may not be set for a windows pod"),
                }
        }

        allErrs := field.ErrorList{}

        if spec.Resources.Claims != nil {
                allErrs = append(allErrs, field.Forbidden(resourcesFldPath.Child("claims"), "claims may not be set for Resources at pod-level"))
        }

        // validatePodResourceRequirements checks if resource names and quantities are
        // valid, and requests are less than limits.
        allErrs = append(allErrs, validatePodResourceRequirements(spec.Resources, podClaimNames, resourcesFldPath, opts)...)
        allErrs = append(allErrs, validatePodResourceConsistency(spec, resourcesFldPath)...)
        return allErrs
}

// validatePodResourceConsistency checks if aggregate container-level requests are
// less than or equal to pod-level requests, and individual container-level limits
// are less than or equal to pod-level limits.
func validatePodResourceConsistency(spec *core.PodSpec, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        // Convert the *core.PodSpec to *v1.PodSpec to satisfy the call to
        // resourcehelper.PodRequests method, in the subsequent lines,
        // which requires a *v1.Pod object (containing a *v1.PodSpec).
        v1PodSpec := &v1.PodSpec{}
        // TODO(ndixita): Convert_core_PodSpec_To_v1_PodSpec is risky. Add a copy of
        // AggregateContainerRequests against internal core.Pod type for beta release of
        // PodLevelResources feature.
        if err := corev1.Convert_core_PodSpec_To_v1_PodSpec(spec, v1PodSpec, nil); err != nil {
                allErrs = append(allErrs, field.InternalError(fldPath, fmt.Errorf("invalid %q: %v", fldPath, err.Error())))
        }

        reqPath := fldPath.Child("requests")
        // resourcehelper.AggregateContainerRequests method requires a Pod object to
        // calculate the total requests requirements of a pod. Hence a Pod object using
        // v1PodSpec i.e. (&v1.Pod{Spec: *v1PodSpec}, is created on the fly, and passed
        // to the AggregateContainerRequests method to facilitate proper resource
        // calculation without modifying AggregateContainerRequests method.
        aggrContainerReqs := resourcehelper.AggregateContainerRequests(&v1.Pod{Spec: *v1PodSpec}, resourcehelper.PodResourcesOptions{})

        // Pod-level requests must be >= aggregate requests of all containers in a pod.
        for resourceName, ctrReqs := range aggrContainerReqs {
                // Skip if the pod-level request of the resource is not set.
                podSpecRequests, exists := spec.Resources.Requests[core.ResourceName(resourceName.String())]
                if !exists {
                        continue
                }

                fldPath := reqPath.Key(resourceName.String())
                if ctrReqs.Cmp(podSpecRequests) > 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath, podSpecRequests.String(), fmt.Sprintf("must be greater than or equal to aggregate container requests of %s", ctrReqs.String())))
                }
        }

        // Pod level hugepage limits must be always equal or greater than the aggregated
        // container level hugepage limits, this is due to the hugepage resources being
        // treated as a non overcommitable resource (request and limit must be equal)
        // for the current container level hugepage behavior.
        // This is also why hugepages overcommitment is not allowed in pod level resources,
        // the pod cgroup values must reflect the request/limit set at pod level, and the
        // container level cgroup values must be within that limit.
        aggrContainerLims := resourcehelper.AggregateContainerLimits(&v1.Pod{Spec: *v1PodSpec}, resourcehelper.PodResourcesOptions{})
        for resourceName, ctrLims := range aggrContainerLims {
                if !helper.IsHugePageResourceName(core.ResourceName(resourceName)) {
                        continue
                }

                podSpecLimits, hasLimit := spec.Resources.Limits[core.ResourceName(resourceName)]
                if !hasLimit {
                        continue
                }

                if ctrLims.Cmp(podSpecLimits) > 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("limits").Key(string(resourceName)), podSpecLimits.String(), fmt.Sprintf("must be greater than or equal to aggregate container limits of %s", ctrLims.String())))
                }
        }

        // Individual Container limits must be <= Pod-level limits.
        for i, ctr := range spec.Containers {
                for resourceName, ctrLimit := range ctr.Resources.Limits {
                        // Skip if the pod-level limit of the resource is not set.
                        podSpecLimits, exists := spec.Resources.Limits[core.ResourceName(resourceName.String())]
                        if !exists {
                                continue
                        }

                        if ctrLimit.Cmp(podSpecLimits) > 0 {
                                fldPath := fldPath.Child("containers").Index(i).Key(resourceName.String()).Child("limits")
                                allErrs = append(allErrs, field.Invalid(fldPath, ctrLimit.String(), fmt.Sprintf("must be less than or equal to pod limits of %s", podSpecLimits.String())))
                        }
                }
        }
        return allErrs
}

func validateLinux(spec *core.PodSpec, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        securityContext := spec.SecurityContext
        if securityContext != nil && securityContext.WindowsOptions != nil {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("windowsOptions"), "windows options cannot be set for a linux pod"))
        }
        podshelper.VisitContainersWithPath(spec, fldPath, func(c *core.Container, cFldPath *field.Path) bool {
                sc := c.SecurityContext
                if sc != nil && sc.WindowsOptions != nil {
                        fldPath := cFldPath.Child("securityContext")
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("windowsOptions"), "windows options cannot be set for a linux pod"))
                }
                return true
        })
        return allErrs
}

func validateWindows(spec *core.PodSpec, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        securityContext := spec.SecurityContext
        // validate Pod SecurityContext
        if securityContext != nil {
                if securityContext.AppArmorProfile != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("appArmorProfile"), "cannot be set for a windows pod"))
                }
                if securityContext.SELinuxOptions != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("seLinuxOptions"), "cannot be set for a windows pod"))
                }
                if securityContext.HostUsers != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostUsers"), "cannot be set for a windows pod"))
                }
                if securityContext.HostPID {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostPID"), "cannot be set for a windows pod"))
                }
                if securityContext.HostIPC {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("hostIPC"), "cannot be set for a windows pod"))
                }
                if securityContext.SeccompProfile != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("seccompProfile"), "cannot be set for a windows pod"))
                }
                if securityContext.FSGroup != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("fsGroup"), "cannot be set for a windows pod"))
                }
                if securityContext.FSGroupChangePolicy != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("fsGroupChangePolicy"), "cannot be set for a windows pod"))
                }
                if len(securityContext.Sysctls) > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("sysctls"), "cannot be set for a windows pod"))
                }
                if securityContext.ShareProcessNamespace != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("shareProcessNamespace"), "cannot be set for a windows pod"))
                }
                if securityContext.RunAsUser != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("runAsUser"), "cannot be set for a windows pod"))
                }
                if securityContext.RunAsGroup != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("runAsGroup"), "cannot be set for a windows pod"))
                }
                if securityContext.SupplementalGroups != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("supplementalGroups"), "cannot be set for a windows pod"))
                }
                if securityContext.SupplementalGroupsPolicy != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("supplementalGroupsPolicy"), "cannot be set for a windows pod"))
                }
                if securityContext.SELinuxChangePolicy != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("securityContext").Child("seLinuxChangePolicy"), "cannot be set for a windows pod"))
                }
        }
        podshelper.VisitContainersWithPath(spec, fldPath, func(c *core.Container, cFldPath *field.Path) bool {
                // validate container security context
                sc := c.SecurityContext
                // OS based podSecurityContext validation
                // There is some naming overlap between Windows and Linux Security Contexts but all the Windows Specific options
                // are set via securityContext.WindowsOptions which we validate below
                // TODO: Think if we need to relax this restriction or some of the restrictions
                if sc != nil {
                        fldPath := cFldPath.Child("securityContext")
                        if sc.AppArmorProfile != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("appArmorProfile"), "cannot be set for a windows pod"))
                        }
                        if sc.SELinuxOptions != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("seLinuxOptions"), "cannot be set for a windows pod"))
                        }
                        if sc.SeccompProfile != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("seccompProfile"), "cannot be set for a windows pod"))
                        }
                        if sc.Capabilities != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("capabilities"), "cannot be set for a windows pod"))
                        }
                        if sc.ReadOnlyRootFilesystem != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("readOnlyRootFilesystem"), "cannot be set for a windows pod"))
                        }
                        if sc.Privileged != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("privileged"), "cannot be set for a windows pod"))
                        }
                        if sc.AllowPrivilegeEscalation != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("allowPrivilegeEscalation"), "cannot be set for a windows pod"))
                        }
                        if sc.ProcMount != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("procMount"), "cannot be set for a windows pod"))
                        }
                        if sc.RunAsUser != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("runAsUser"), "cannot be set for a windows pod"))
                        }
                        if sc.RunAsGroup != nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Child("runAsGroup"), "cannot be set for a windows pod"))
                        }
                }
                return true
        })
        return allErrs
}

// ValidateNodeSelectorRequirement tests that the specified NodeSelectorRequirement fields has valid data
func ValidateNodeSelectorRequirement(rq core.NodeSelectorRequirement, allowInvalidLabelValueInRequiredNodeAffinity bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        switch rq.Operator {
        case core.NodeSelectorOpIn, core.NodeSelectorOpNotIn:
                if len(rq.Values) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("values"), "must be specified when `operator` is 'In' or 'NotIn'"))
                }
        case core.NodeSelectorOpExists, core.NodeSelectorOpDoesNotExist:
                if len(rq.Values) > 0 {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("values"), "may not be specified when `operator` is 'Exists' or 'DoesNotExist'"))
                }

        case core.NodeSelectorOpGt, core.NodeSelectorOpLt:
                if len(rq.Values) != 1 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("values"), "must be specified single value when `operator` is 'Lt' or 'Gt'"))
                }
        default:
                allErrs = append(allErrs, field.Invalid(fldPath.Child("operator"), rq.Operator, "not a valid selector operator"))
        }
        allErrs = append(allErrs, unversionedvalidation.ValidateLabelName(rq.Key, fldPath.Child("key"))...)
        if !allowInvalidLabelValueInRequiredNodeAffinity {
                path := fldPath.Child("values")
                for valueIndex, value := range rq.Values {
                        for _, msg := range validation.IsValidLabelValue(value) {
                                allErrs = append(allErrs, field.Invalid(path.Index(valueIndex), value, msg)).WithOrigin("format=k8s-label-value")
                        }
                }
        }
        return allErrs
}

var nodeFieldSelectorValidators = map[string]func(string, bool) []string{
        metav1.ObjectNameField: ValidateNodeName,
}

// ValidateNodeFieldSelectorRequirement tests that the specified NodeSelectorRequirement fields has valid data
func ValidateNodeFieldSelectorRequirement(req core.NodeSelectorRequirement, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        switch req.Operator {
        case core.NodeSelectorOpIn, core.NodeSelectorOpNotIn:
                if len(req.Values) != 1 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("values"),
                                "must be only one value when `operator` is 'In' or 'NotIn' for node field selector"))
                }
        default:
                allErrs = append(allErrs, field.Invalid(fldPath.Child("operator"), req.Operator, "not a valid selector operator"))
        }

        if vf, found := nodeFieldSelectorValidators[req.Key]; !found {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("key"), req.Key, "not a valid field selector key"))
        } else {
                for i, v := range req.Values {
                        for _, msg := range vf(v, false) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("values").Index(i), v, msg))
                        }
                }
        }

        return allErrs
}

// ValidateNodeSelectorTerm tests that the specified node selector term has valid data
func ValidateNodeSelectorTerm(term core.NodeSelectorTerm, allowInvalidLabelValueInRequiredNodeAffinity bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        for j, req := range term.MatchExpressions {
                allErrs = append(allErrs, ValidateNodeSelectorRequirement(req, allowInvalidLabelValueInRequiredNodeAffinity, fldPath.Child("matchExpressions").Index(j))...)
        }

        for j, req := range term.MatchFields {
                allErrs = append(allErrs, ValidateNodeFieldSelectorRequirement(req, fldPath.Child("matchFields").Index(j))...)
        }

        return allErrs
}

// ValidateNodeSelector tests that the specified nodeSelector fields has valid data
func ValidateNodeSelector(nodeSelector *core.NodeSelector, allowInvalidLabelValueInRequiredNodeAffinity bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        termFldPath := fldPath.Child("nodeSelectorTerms")
        if len(nodeSelector.NodeSelectorTerms) == 0 {
                return append(allErrs, field.Required(termFldPath, "must have at least one node selector term"))
        }

        for i, term := range nodeSelector.NodeSelectorTerms {
                allErrs = append(allErrs, ValidateNodeSelectorTerm(term, allowInvalidLabelValueInRequiredNodeAffinity, termFldPath.Index(i))...)
        }

        return allErrs
}

// validateTopologySelectorLabelRequirement tests that the specified TopologySelectorLabelRequirement fields has valid data,
// and constructs a set containing all of its Values.
func validateTopologySelectorLabelRequirement(rq core.TopologySelectorLabelRequirement, fldPath *field.Path) (sets.Set[string], field.ErrorList) {
        allErrs := field.ErrorList{}
        valueSet := make(sets.Set[string])
        valuesPath := fldPath.Child("values")
        if len(rq.Values) == 0 {
                allErrs = append(allErrs, field.Required(valuesPath, ""))
        }

        // Validate set property of Values field
        for i, value := range rq.Values {
                if valueSet.Has(value) {
                        allErrs = append(allErrs, field.Duplicate(valuesPath.Index(i), value))
                }
                valueSet.Insert(value)
        }

        allErrs = append(allErrs, unversionedvalidation.ValidateLabelName(rq.Key, fldPath.Child("key"))...)

        return valueSet, allErrs
}

// ValidateTopologySelectorTerm tests that the specified topology selector term has valid data,
// and constructs a map representing the term in raw form.
func ValidateTopologySelectorTerm(term core.TopologySelectorTerm, fldPath *field.Path) (map[string]sets.Set[string], field.ErrorList) {
        allErrs := field.ErrorList{}
        exprMap := make(map[string]sets.Set[string])
        exprPath := fldPath.Child("matchLabelExpressions")

        // Allow empty MatchLabelExpressions, in case this field becomes optional in the future.
        for i, req := range term.MatchLabelExpressions {
                idxPath := exprPath.Index(i)
                valueSet, exprErrs := validateTopologySelectorLabelRequirement(req, idxPath)
                allErrs = append(allErrs, exprErrs...)

                // Validate no duplicate keys exist.
                if _, exists := exprMap[req.Key]; exists {
                        allErrs = append(allErrs, field.Duplicate(idxPath.Child("key"), req.Key))
                }
                exprMap[req.Key] = valueSet
        }

        return exprMap, allErrs
}

// ValidateAvoidPodsInNodeAnnotations tests that the serialized AvoidPods in Node.Annotations has valid data
func ValidateAvoidPodsInNodeAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        v1Avoids, err := schedulinghelper.GetAvoidPodsFromNodeAnnotations(annotations)
        if err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("AvoidPods"), core.PreferAvoidPodsAnnotationKey, err.Error()))
                return allErrs
        }
        var avoids core.AvoidPods
        if err := corev1.Convert_v1_AvoidPods_To_core_AvoidPods(&v1Avoids, &avoids, nil); err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("AvoidPods"), core.PreferAvoidPodsAnnotationKey, err.Error()))
                return allErrs
        }

        if len(avoids.PreferAvoidPods) != 0 {
                for i, pa := range avoids.PreferAvoidPods {
                        idxPath := fldPath.Child(core.PreferAvoidPodsAnnotationKey).Index(i)
                        allErrs = append(allErrs, validatePreferAvoidPodsEntry(pa, idxPath)...)
                }
        }

        return allErrs
}

// validatePreferAvoidPodsEntry tests if given PreferAvoidPodsEntry has valid data.
func validatePreferAvoidPodsEntry(avoidPodEntry core.PreferAvoidPodsEntry, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        if avoidPodEntry.PodSignature.PodController == nil {
                allErrors = append(allErrors, field.Required(fldPath.Child("PodSignature"), ""))
        } else {
                if !*(avoidPodEntry.PodSignature.PodController.Controller) {
                        allErrors = append(allErrors,
                                field.Invalid(fldPath.Child("PodSignature").Child("PodController").Child("Controller"),
                                        *(avoidPodEntry.PodSignature.PodController.Controller), "must point to a controller"))
                }
        }
        return allErrors
}

// ValidatePreferredSchedulingTerms tests that the specified SoftNodeAffinity fields has valid data
func ValidatePreferredSchedulingTerms(terms []core.PreferredSchedulingTerm, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        for i, term := range terms {
                if term.Weight <= 0 || term.Weight > 100 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("weight"), term.Weight, "must be in the range 1-100"))
                }

                // we always allow invalid label-value for preferred affinity
                // as they can success when cluster has only one node
                allErrs = append(allErrs, ValidateNodeSelectorTerm(term.Preference, true, fldPath.Index(i).Child("preference"))...)
        }
        return allErrs
}

// validatePodAffinityTerm tests that the specified podAffinityTerm fields have valid data
func validatePodAffinityTerm(podAffinityTerm core.PodAffinityTerm, allowInvalidLabelValueInSelector bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        allErrs = append(allErrs, ValidatePodAffinityTermSelector(podAffinityTerm, allowInvalidLabelValueInSelector, fldPath)...)
        for _, name := range podAffinityTerm.Namespaces {
                for _, msg := range ValidateNamespaceName(name, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), name, msg))
                }
        }
        allErrs = append(allErrs, ValidateMatchLabelKeysAndMismatchLabelKeys(fldPath, podAffinityTerm.MatchLabelKeys, podAffinityTerm.MismatchLabelKeys, podAffinityTerm.LabelSelector)...)
        if len(podAffinityTerm.TopologyKey) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("topologyKey"), "can not be empty"))
        }
        return append(allErrs, unversionedvalidation.ValidateLabelName(podAffinityTerm.TopologyKey, fldPath.Child("topologyKey"))...)
}

// validatePodAffinityTerms tests that the specified podAffinityTerms fields have valid data
func validatePodAffinityTerms(podAffinityTerms []core.PodAffinityTerm, allowInvalidLabelValueInSelector bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for i, podAffinityTerm := range podAffinityTerms {
                allErrs = append(allErrs, validatePodAffinityTerm(podAffinityTerm, allowInvalidLabelValueInSelector, fldPath.Index(i))...)
        }
        return allErrs
}

// validateWeightedPodAffinityTerms tests that the specified weightedPodAffinityTerms fields have valid data
func validateWeightedPodAffinityTerms(weightedPodAffinityTerms []core.WeightedPodAffinityTerm, allowInvalidLabelValueInSelector bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for j, weightedTerm := range weightedPodAffinityTerms {
                if weightedTerm.Weight <= 0 || weightedTerm.Weight > 100 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Index(j).Child("weight"), weightedTerm.Weight, "must be in the range 1-100"))
                }
                allErrs = append(allErrs, validatePodAffinityTerm(weightedTerm.PodAffinityTerm, allowInvalidLabelValueInSelector, fldPath.Index(j).Child("podAffinityTerm"))...)
        }
        return allErrs
}

// validatePodAntiAffinity tests that the specified podAntiAffinity fields have valid data
func validatePodAntiAffinity(podAntiAffinity *core.PodAntiAffinity, allowInvalidLabelValueInSelector bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        // TODO:Uncomment below code once RequiredDuringSchedulingRequiredDuringExecution is implemented.
        // if podAntiAffinity.RequiredDuringSchedulingRequiredDuringExecution != nil {
        //        allErrs = append(allErrs, validatePodAffinityTerms(podAntiAffinity.RequiredDuringSchedulingRequiredDuringExecution, false,
        //                fldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...)
        // }
        if podAntiAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil {
                allErrs = append(allErrs, validatePodAffinityTerms(podAntiAffinity.RequiredDuringSchedulingIgnoredDuringExecution, allowInvalidLabelValueInSelector,
                        fldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...)
        }
        if podAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution != nil {
                allErrs = append(allErrs, validateWeightedPodAffinityTerms(podAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution, allowInvalidLabelValueInSelector,
                        fldPath.Child("preferredDuringSchedulingIgnoredDuringExecution"))...)
        }
        return allErrs
}

// validateNodeAffinity tests that the specified nodeAffinity fields have valid data
func validateNodeAffinity(na *core.NodeAffinity, opts PodValidationOptions, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        // TODO: Uncomment the next three lines once RequiredDuringSchedulingRequiredDuringExecution is implemented.
        // if na.RequiredDuringSchedulingRequiredDuringExecution != nil {
        //        allErrs = append(allErrs, ValidateNodeSelector(na.RequiredDuringSchedulingRequiredDuringExecution, fldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...)
        // }
        if na.RequiredDuringSchedulingIgnoredDuringExecution != nil {
                allErrs = append(allErrs, ValidateNodeSelector(na.RequiredDuringSchedulingIgnoredDuringExecution, opts.AllowInvalidLabelValueInRequiredNodeAffinity, fldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...)
        }
        if len(na.PreferredDuringSchedulingIgnoredDuringExecution) > 0 {
                allErrs = append(allErrs, ValidatePreferredSchedulingTerms(na.PreferredDuringSchedulingIgnoredDuringExecution, fldPath.Child("preferredDuringSchedulingIgnoredDuringExecution"))...)
        }
        return allErrs
}

// validatePodAffinity tests that the specified podAffinity fields have valid data
func validatePodAffinity(podAffinity *core.PodAffinity, allowInvalidLabelValueInSelector bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        // TODO:Uncomment below code once RequiredDuringSchedulingRequiredDuringExecution is implemented.
        // if podAffinity.RequiredDuringSchedulingRequiredDuringExecution != nil {
        //        allErrs = append(allErrs, validatePodAffinityTerms(podAffinity.RequiredDuringSchedulingRequiredDuringExecution, false,
        //                fldPath.Child("requiredDuringSchedulingRequiredDuringExecution"))...)
        // }
        if podAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil {
                allErrs = append(allErrs, validatePodAffinityTerms(podAffinity.RequiredDuringSchedulingIgnoredDuringExecution, allowInvalidLabelValueInSelector,
                        fldPath.Child("requiredDuringSchedulingIgnoredDuringExecution"))...)
        }
        if podAffinity.PreferredDuringSchedulingIgnoredDuringExecution != nil {
                allErrs = append(allErrs, validateWeightedPodAffinityTerms(podAffinity.PreferredDuringSchedulingIgnoredDuringExecution, allowInvalidLabelValueInSelector,
                        fldPath.Child("preferredDuringSchedulingIgnoredDuringExecution"))...)
        }
        return allErrs
}

func validateSeccompProfileField(sp *core.SeccompProfile, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if sp == nil {
                return allErrs
        }

        if err := validateSeccompProfileType(fldPath.Child("type"), sp.Type); err != nil {
                allErrs = append(allErrs, err)
        }

        if sp.Type == core.SeccompProfileTypeLocalhost {
                if sp.LocalhostProfile == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("localhostProfile"), "must be set when seccomp type is Localhost"))
                } else {
                        allErrs = append(allErrs, validateLocalDescendingPath(*sp.LocalhostProfile, fldPath.Child("localhostProfile"))...)
                }
        } else {
                if sp.LocalhostProfile != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("localhostProfile"), sp, "can only be set when seccomp type is Localhost"))
                }
        }

        return allErrs
}

func ValidateSeccompProfile(p string, fldPath *field.Path) field.ErrorList {
        if p == core.SeccompProfileRuntimeDefault || p == core.DeprecatedSeccompProfileDockerDefault {
                return nil
        }
        if p == v1.SeccompProfileNameUnconfined {
                return nil
        }
        if strings.HasPrefix(p, v1.SeccompLocalhostProfileNamePrefix) {
                return validateLocalDescendingPath(strings.TrimPrefix(p, v1.SeccompLocalhostProfileNamePrefix), fldPath)
        }
        return field.ErrorList{field.Invalid(fldPath, p, "must be a valid seccomp profile")}
}

func ValidateSeccompPodAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if p, exists := annotations[core.SeccompPodAnnotationKey]; exists {
                allErrs = append(allErrs, ValidateSeccompProfile(p, fldPath.Child(core.SeccompPodAnnotationKey))...)
        }
        for k, p := range annotations {
                if strings.HasPrefix(k, core.SeccompContainerAnnotationKeyPrefix) {
                        allErrs = append(allErrs, ValidateSeccompProfile(p, fldPath.Child(k))...)
                }
        }

        return allErrs
}

// ValidateSeccompProfileType tests that the argument is a valid SeccompProfileType.
func validateSeccompProfileType(fldPath *field.Path, seccompProfileType core.SeccompProfileType) *field.Error {
        switch seccompProfileType {
        case core.SeccompProfileTypeLocalhost, core.SeccompProfileTypeRuntimeDefault, core.SeccompProfileTypeUnconfined:
                return nil
        case "":
                return field.Required(fldPath, "type is required when seccompProfile is set")
        default:
                return field.NotSupported(fldPath, seccompProfileType, []core.SeccompProfileType{core.SeccompProfileTypeLocalhost, core.SeccompProfileTypeRuntimeDefault, core.SeccompProfileTypeUnconfined})
        }
}

func ValidateAppArmorProfileField(profile *core.AppArmorProfile, fldPath *field.Path) field.ErrorList {
        if profile == nil {
                return nil
        }

        allErrs := field.ErrorList{}

        switch profile.Type {
        case core.AppArmorProfileTypeLocalhost:
                if profile.LocalhostProfile == nil {
                        allErrs = append(allErrs, field.Required(fldPath.Child("localhostProfile"), "must be set when AppArmor type is Localhost"))
                } else {
                        localhostProfile := strings.TrimSpace(*profile.LocalhostProfile)
                        if localhostProfile != *profile.LocalhostProfile {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("localhostProfile"), *profile.LocalhostProfile, "must not be padded with whitespace"))
                        } else if localhostProfile == "" {
                                allErrs = append(allErrs, field.Required(fldPath.Child("localhostProfile"), "must be set when AppArmor type is Localhost"))
                        }

                        const maxLocalhostProfileLength = 4095 // PATH_MAX - 1
                        if len(*profile.LocalhostProfile) > maxLocalhostProfileLength {
                                allErrs = append(allErrs, field.TooLong(fldPath.Child("localhostProfile"), "" /*unused*/, maxLocalhostProfileLength))
                        }
                }

        case core.AppArmorProfileTypeRuntimeDefault, core.AppArmorProfileTypeUnconfined:
                if profile.LocalhostProfile != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("localhostProfile"), profile.LocalhostProfile, "can only be set when AppArmor type is Localhost"))
                }

        case "":
                allErrs = append(allErrs, field.Required(fldPath.Child("type"), "type is required when appArmorProfile is set"))

        default:
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("type"), profile.Type,
                        []core.AppArmorProfileType{core.AppArmorProfileTypeLocalhost, core.AppArmorProfileTypeRuntimeDefault, core.AppArmorProfileTypeUnconfined}))
        }

        return allErrs

}

func ValidateAppArmorPodAnnotations(annotations map[string]string, spec *core.PodSpec, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for k, p := range annotations {
                if !strings.HasPrefix(k, v1.DeprecatedAppArmorBetaContainerAnnotationKeyPrefix) {
                        continue
                }
                containerName := strings.TrimPrefix(k, v1.DeprecatedAppArmorBetaContainerAnnotationKeyPrefix)
                if !podSpecHasContainer(spec, containerName) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Key(k), containerName, "container not found"))
                }

                if err := ValidateAppArmorProfileFormat(p); err != nil {
                        allErrs = append(allErrs, field.Invalid(fldPath.Key(k), p, err.Error()))
                }
        }

        return allErrs
}

func ValidateAppArmorProfileFormat(profile string) error {
        if profile == "" || profile == v1.DeprecatedAppArmorBetaProfileRuntimeDefault || profile == v1.DeprecatedAppArmorBetaProfileNameUnconfined {
                return nil
        }
        if !strings.HasPrefix(profile, v1.DeprecatedAppArmorBetaProfileNamePrefix) {
                return fmt.Errorf("invalid AppArmor profile name: %q", profile)
        }
        return nil
}

// validateAppArmorAnnotationsAndFieldsMatchOnCreate validates that AppArmor fields and annotations are consistent.
func validateAppArmorAnnotationsAndFieldsMatchOnCreate(objectMeta metav1.ObjectMeta, podSpec *core.PodSpec, specPath *field.Path) field.ErrorList {
        if podSpec.OS != nil && podSpec.OS.Name == core.Windows {
                // Skip consistency check for windows pods.
                return nil
        }

        allErrs := field.ErrorList{}

        var podProfile *core.AppArmorProfile
        if podSpec.SecurityContext != nil {
                podProfile = podSpec.SecurityContext.AppArmorProfile
        }
        podshelper.VisitContainersWithPath(podSpec, specPath, func(c *core.Container, cFldPath *field.Path) bool {
                containerProfile := podProfile
                if c.SecurityContext != nil && c.SecurityContext.AppArmorProfile != nil {
                        containerProfile = c.SecurityContext.AppArmorProfile
                }

                if containerProfile == nil {
                        return true
                }

                key := core.DeprecatedAppArmorAnnotationKeyPrefix + c.Name
                if annotation, found := objectMeta.Annotations[key]; found {
                        apparmorPath := cFldPath.Child("securityContext").Child("appArmorProfile")

                        switch containerProfile.Type {
                        case core.AppArmorProfileTypeUnconfined:
                                if annotation != core.DeprecatedAppArmorAnnotationValueUnconfined {
                                        allErrs = append(allErrs, field.Forbidden(apparmorPath.Child("type"), "apparmor type in annotation and field must match"))
                                }

                        case core.AppArmorProfileTypeRuntimeDefault:
                                if annotation != core.DeprecatedAppArmorAnnotationValueRuntimeDefault {
                                        allErrs = append(allErrs, field.Forbidden(apparmorPath.Child("type"), "apparmor type in annotation and field must match"))
                                }

                        case core.AppArmorProfileTypeLocalhost:
                                if !strings.HasPrefix(annotation, core.DeprecatedAppArmorAnnotationValueLocalhostPrefix) {
                                        allErrs = append(allErrs, field.Forbidden(apparmorPath.Child("type"), "apparmor type in annotation and field must match"))
                                } else if containerProfile.LocalhostProfile == nil || strings.TrimPrefix(annotation, core.DeprecatedAppArmorAnnotationValueLocalhostPrefix) != *containerProfile.LocalhostProfile {
                                        allErrs = append(allErrs, field.Forbidden(apparmorPath.Child("localhostProfile"), "apparmor profile in annotation and field must match"))
                                }
                        }
                }
                return true
        })

        return allErrs
}

func podSpecHasContainer(spec *core.PodSpec, containerName string) bool {
        var hasContainer bool
        podshelper.VisitContainersWithPath(spec, field.NewPath("spec"), func(c *core.Container, _ *field.Path) bool {
                if c.Name == containerName {
                        hasContainer = true
                        return false
                }
                return true
        })
        return hasContainer
}

const (
        // a sysctl segment regex, concatenated with dots to form a sysctl name
        SysctlSegmentFmt string = "[a-z0-9]([-_a-z0-9]*[a-z0-9])?"

        // a sysctl name regex with slash allowed
        SysctlContainSlashFmt string = "(" + SysctlSegmentFmt + "[\\./])*" + SysctlSegmentFmt

        // the maximal length of a sysctl name
        SysctlMaxLength int = 253
)

var sysctlContainSlashRegexp = regexp.MustCompile("^" + SysctlContainSlashFmt + "$")

// IsValidSysctlName checks that the given string is a valid sysctl name,
// i.e. matches SysctlContainSlashFmt.
// More info:
//
//        https://man7.org/linux/man-pages/man8/sysctl.8.html
//        https://man7.org/linux/man-pages/man5/sysctl.d.5.html
func IsValidSysctlName(name string) bool {
        if len(name) > SysctlMaxLength {
                return false
        }
        return sysctlContainSlashRegexp.MatchString(name)
}

func validateSysctls(securityContext *core.PodSecurityContext, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        names := make(map[string]struct{})
        for i, s := range securityContext.Sysctls {
                if len(s.Name) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Index(i).Child("name"), ""))
                } else if !IsValidSysctlName(s.Name) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("name"), s.Name, fmt.Sprintf("must have at most %d characters and match regex %s", SysctlMaxLength, sysctlContainSlashRegexp)))
                } else if _, ok := names[s.Name]; ok {
                        allErrs = append(allErrs, field.Duplicate(fldPath.Index(i).Child("name"), s.Name))
                }
                if !opts.AllowNamespacedSysctlsForHostNetAndHostIPC {
                        err := ValidateHostSysctl(s.Name, securityContext, fldPath.Index(i).Child("name"))
                        if err != nil {
                                allErrs = append(allErrs, err)
                        }
                }
                names[s.Name] = struct{}{}
        }
        return allErrs
}

// ValidateHostSysctl will return error if namespaced sysctls is applied to pod sharing the respective namespaces with the host.
func ValidateHostSysctl(sysctl string, securityContext *core.PodSecurityContext, fldPath *field.Path) *field.Error {
        ns, _, _ := utilsysctl.GetNamespace(sysctl)
        switch {
        case securityContext.HostNetwork && ns == utilsysctl.NetNamespace:
                return field.Invalid(fldPath, sysctl, "may not be specified when 'hostNetwork' is true")
        case securityContext.HostIPC && ns == utilsysctl.IPCNamespace:
                return field.Invalid(fldPath, sysctl, "may not be specified when 'hostIPC' is true")
        }
        return nil
}

var validSELinuxChangePolicies = sets.New(core.SELinuxChangePolicyRecursive, core.SELinuxChangePolicyMountOption)

func validateSELinuxChangePolicy(seLinuxChangePolicy *core.PodSELinuxChangePolicy, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        if seLinuxChangePolicy == nil {
                return nil
        }

        allErrs := field.ErrorList{}

        if opts.AllowOnlyRecursiveSELinuxChangePolicy {
                if *seLinuxChangePolicy != core.SELinuxChangePolicyRecursive {
                        allErrs = append(allErrs, field.NotSupported(fldPath, *seLinuxChangePolicy, []core.PodSELinuxChangePolicy{core.SELinuxChangePolicyRecursive}))
                }
        } else {
                // Allow any valid SELinuxChangePolicy value.
                if !validSELinuxChangePolicies.Has(*seLinuxChangePolicy) {
                        allErrs = append(allErrs, field.NotSupported(fldPath, *seLinuxChangePolicy, sets.List(validSELinuxChangePolicies)))
                }
        }
        return allErrs
}

// validatePodSpecSecurityContext verifies the SecurityContext of a PodSpec,
// whether that is defined in a Pod or in an embedded PodSpec (e.g. a
// Deployment's pod template).
func validatePodSpecSecurityContext(securityContext *core.PodSecurityContext, spec *core.PodSpec, specPath, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        if securityContext != nil {
                if securityContext.FSGroup != nil {
                        for _, msg := range validation.IsValidGroupID(*securityContext.FSGroup) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("fsGroup"), *(securityContext.FSGroup), msg))
                        }
                }
                if securityContext.RunAsUser != nil {
                        for _, msg := range validation.IsValidUserID(*securityContext.RunAsUser) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("runAsUser"), *(securityContext.RunAsUser), msg))
                        }
                }
                if securityContext.RunAsGroup != nil {
                        for _, msg := range validation.IsValidGroupID(*securityContext.RunAsGroup) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("runAsGroup"), *(securityContext.RunAsGroup), msg))
                        }
                }
                for g, gid := range securityContext.SupplementalGroups {
                        for _, msg := range validation.IsValidGroupID(gid) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("supplementalGroups").Index(g), gid, msg))
                        }
                }
                if securityContext.ShareProcessNamespace != nil && securityContext.HostPID && *securityContext.ShareProcessNamespace {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("shareProcessNamespace"), *securityContext.ShareProcessNamespace, "ShareProcessNamespace and HostPID cannot both be enabled"))
                }

                if len(securityContext.Sysctls) != 0 {
                        allErrs = append(allErrs, validateSysctls(securityContext, fldPath.Child("sysctls"), opts)...)
                }

                if securityContext.FSGroupChangePolicy != nil {
                        allErrs = append(allErrs, validateFSGroupChangePolicy(securityContext.FSGroupChangePolicy, fldPath.Child("fsGroupChangePolicy"))...)
                }

                allErrs = append(allErrs, validateSeccompProfileField(securityContext.SeccompProfile, fldPath.Child("seccompProfile"))...)
                allErrs = append(allErrs, validateWindowsSecurityContextOptions(securityContext.WindowsOptions, fldPath.Child("windowsOptions"))...)
                allErrs = append(allErrs, ValidateAppArmorProfileField(securityContext.AppArmorProfile, fldPath.Child("appArmorProfile"))...)

                if securityContext.SupplementalGroupsPolicy != nil {
                        allErrs = append(allErrs, validateSupplementalGroupsPolicy(securityContext.SupplementalGroupsPolicy, fldPath.Child("supplementalGroupsPolicy"))...)
                }

                if securityContext.SELinuxChangePolicy != nil {
                        allErrs = append(allErrs, validateSELinuxChangePolicy(securityContext.SELinuxChangePolicy, fldPath.Child("seLinuxChangePolicy"), opts)...)
                }
        }

        return allErrs
}

func ValidateContainerUpdates(newContainers, oldContainers []core.Container, fldPath *field.Path) (allErrs field.ErrorList, stop bool) {
        allErrs = field.ErrorList{}
        if len(newContainers) != len(oldContainers) {
                // TODO: Pinpoint the specific container that causes the invalid error after we have strategic merge diff
                allErrs = append(allErrs, field.Forbidden(fldPath, "pod updates may not add or remove containers"))
                return allErrs, true
        }

        // validate updated container images
        for i, ctr := range newContainers {
                if len(ctr.Image) == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Index(i).Child("image"), ""))
                }
                // this is only called from ValidatePodUpdate so its safe to check leading/trailing whitespace.
                if len(strings.TrimSpace(ctr.Image)) != len(ctr.Image) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("image"), ctr.Image, "must not have leading or trailing whitespace"))
                }
        }
        return allErrs, false
}

// ValidatePodCreate validates a pod in the context of its initial create
func ValidatePodCreate(pod *core.Pod, opts PodValidationOptions) field.ErrorList {
        allErrs := validatePodMetadataAndSpec(pod, opts)

        fldPath := field.NewPath("spec")
        // EphemeralContainers can only be set on update using the ephemeralcontainers subresource
        if len(pod.Spec.EphemeralContainers) > 0 {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("ephemeralContainers"), "cannot be set on create"))
        }
        // A Pod cannot be assigned a Node if there are remaining scheduling gates.
        if pod.Spec.NodeName != "" && len(pod.Spec.SchedulingGates) != 0 {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("nodeName"), "cannot be set until all schedulingGates have been cleared"))
        }
        allErrs = append(allErrs, validateSeccompAnnotationsAndFields(pod.ObjectMeta, &pod.Spec, fldPath)...)
        allErrs = append(allErrs, validateAppArmorAnnotationsAndFieldsMatchOnCreate(pod.ObjectMeta, &pod.Spec, fldPath)...)

        return allErrs
}

// validateSeccompAnnotationsAndFields iterates through all containers and ensure that when both seccompProfile and seccomp annotations exist they match.
func validateSeccompAnnotationsAndFields(objectMeta metav1.ObjectMeta, podSpec *core.PodSpec, specPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if podSpec.SecurityContext != nil && podSpec.SecurityContext.SeccompProfile != nil {
                // If both seccomp annotations and fields are specified, the values must match.
                if annotation, found := objectMeta.Annotations[v1.SeccompPodAnnotationKey]; found {
                        seccompPath := specPath.Child("securityContext").Child("seccompProfile")
                        err := validateSeccompAnnotationsAndFieldsMatch(annotation, podSpec.SecurityContext.SeccompProfile, seccompPath)
                        if err != nil {
                                allErrs = append(allErrs, err)
                        }
                }
        }

        podshelper.VisitContainersWithPath(podSpec, specPath, func(c *core.Container, cFldPath *field.Path) bool {
                var field *core.SeccompProfile
                if c.SecurityContext != nil {
                        field = c.SecurityContext.SeccompProfile
                }

                if field == nil {
                        return true
                }

                key := v1.SeccompContainerAnnotationKeyPrefix + c.Name
                if annotation, found := objectMeta.Annotations[key]; found {
                        seccompPath := cFldPath.Child("securityContext").Child("seccompProfile")
                        err := validateSeccompAnnotationsAndFieldsMatch(annotation, field, seccompPath)
                        if err != nil {
                                allErrs = append(allErrs, err)
                        }
                }
                return true
        })

        return allErrs
}

func validateSeccompAnnotationsAndFieldsMatch(annotationValue string, seccompField *core.SeccompProfile, fldPath *field.Path) *field.Error {
        if seccompField == nil {
                return nil
        }

        switch seccompField.Type {
        case core.SeccompProfileTypeUnconfined:
                if annotationValue != v1.SeccompProfileNameUnconfined {
                        return field.Forbidden(fldPath.Child("type"), "seccomp type in annotation and field must match")
                }

        case core.SeccompProfileTypeRuntimeDefault:
                if annotationValue != v1.SeccompProfileRuntimeDefault && annotationValue != v1.DeprecatedSeccompProfileDockerDefault {
                        return field.Forbidden(fldPath.Child("type"), "seccomp type in annotation and field must match")
                }

        case core.SeccompProfileTypeLocalhost:
                if !strings.HasPrefix(annotationValue, v1.SeccompLocalhostProfileNamePrefix) {
                        return field.Forbidden(fldPath.Child("type"), "seccomp type in annotation and field must match")
                } else if seccompField.LocalhostProfile == nil || strings.TrimPrefix(annotationValue, v1.SeccompLocalhostProfileNamePrefix) != *seccompField.LocalhostProfile {
                        return field.Forbidden(fldPath.Child("localhostProfile"), "seccomp profile in annotation and field must match")
                }
        }

        return nil
}

var updatablePodSpecFields = []string{
        "`spec.containers[*].image`",
        "`spec.initContainers[*].image`",
        "`spec.activeDeadlineSeconds`",
        "`spec.tolerations` (only additions to existing tolerations)",
        "`spec.terminationGracePeriodSeconds` (allow it to be set to 1 if it was previously negative)",
}

// ValidatePodUpdate tests to see if the update is legal for an end user to make. newPod is updated with fields
// that cannot be changed.
func ValidatePodUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) field.ErrorList {
        fldPath := field.NewPath("metadata")
        allErrs := ValidateObjectMetaUpdate(&newPod.ObjectMeta, &oldPod.ObjectMeta, fldPath)
        allErrs = append(allErrs, validatePodMetadataAndSpec(newPod, opts)...)
        allErrs = append(allErrs, ValidatePodSpecificAnnotationUpdates(newPod, oldPod, fldPath.Child("annotations"), opts)...)
        specPath := field.NewPath("spec")

        // validate updateable fields:
        // 1.  spec.containers[*].image
        // 2.  spec.initContainers[*].image
        // 3.  spec.activeDeadlineSeconds
        // 4.  spec.terminationGracePeriodSeconds
        // 5.  spec.schedulingGates

        containerErrs, stop := ValidateContainerUpdates(newPod.Spec.Containers, oldPod.Spec.Containers, specPath.Child("containers"))
        allErrs = append(allErrs, containerErrs...)
        if stop {
                return allErrs
        }
        containerErrs, stop = ValidateContainerUpdates(newPod.Spec.InitContainers, oldPod.Spec.InitContainers, specPath.Child("initContainers"))
        allErrs = append(allErrs, containerErrs...)
        if stop {
                return allErrs
        }

        // validate updated spec.activeDeadlineSeconds.  two types of updates are allowed:
        // 1.  from nil to a positive value
        // 2.  from a positive value to a lesser, non-negative value
        if newPod.Spec.ActiveDeadlineSeconds != nil {
                newActiveDeadlineSeconds := *newPod.Spec.ActiveDeadlineSeconds
                if newActiveDeadlineSeconds < 0 || newActiveDeadlineSeconds > math.MaxInt32 {
                        allErrs = append(allErrs, field.Invalid(specPath.Child("activeDeadlineSeconds"), newActiveDeadlineSeconds, validation.InclusiveRangeError(0, math.MaxInt32)))
                        return allErrs
                }
                if oldPod.Spec.ActiveDeadlineSeconds != nil {
                        oldActiveDeadlineSeconds := *oldPod.Spec.ActiveDeadlineSeconds
                        if oldActiveDeadlineSeconds < newActiveDeadlineSeconds {
                                allErrs = append(allErrs, field.Invalid(specPath.Child("activeDeadlineSeconds"), newActiveDeadlineSeconds, "must be less than or equal to previous value"))
                                return allErrs
                        }
                }
        } else if oldPod.Spec.ActiveDeadlineSeconds != nil {
                allErrs = append(allErrs, field.Invalid(specPath.Child("activeDeadlineSeconds"), newPod.Spec.ActiveDeadlineSeconds, "must not update from a positive integer to nil value"))
        }

        // Allow only additions to tolerations updates.
        allErrs = append(allErrs, validateOnlyAddedTolerations(newPod.Spec.Tolerations, oldPod.Spec.Tolerations, specPath.Child("tolerations"))...)

        // Allow only deletions to schedulingGates updates.
        allErrs = append(allErrs, validateOnlyDeletedSchedulingGates(newPod.Spec.SchedulingGates, oldPod.Spec.SchedulingGates, specPath.Child("schedulingGates"))...)

        // the last thing to check is pod spec equality.  If the pod specs are equal, then we can simply return the errors we have
        // so far and save the cost of a deep copy.
        if apiequality.Semantic.DeepEqual(newPod.Spec, oldPod.Spec) {
                return allErrs
        }

        // handle updateable fields by munging those fields prior to deep equal comparison.
        mungedPodSpec := *newPod.Spec.DeepCopy()
        // munge spec.containers[*].image
        var newContainers []core.Container
        for ix, container := range mungedPodSpec.Containers {
                container.Image = oldPod.Spec.Containers[ix].Image // +k8s:verify-mutation:reason=clone
                newContainers = append(newContainers, container)
        }
        mungedPodSpec.Containers = newContainers
        // munge spec.initContainers[*].image
        var newInitContainers []core.Container
        for ix, container := range mungedPodSpec.InitContainers {
                container.Image = oldPod.Spec.InitContainers[ix].Image // +k8s:verify-mutation:reason=clone
                newInitContainers = append(newInitContainers, container)
        }
        mungedPodSpec.InitContainers = newInitContainers
        // munge spec.activeDeadlineSeconds
        mungedPodSpec.ActiveDeadlineSeconds = nil
        if oldPod.Spec.ActiveDeadlineSeconds != nil {
                activeDeadlineSeconds := *oldPod.Spec.ActiveDeadlineSeconds
                mungedPodSpec.ActiveDeadlineSeconds = &activeDeadlineSeconds
        }
        // munge spec.schedulingGates
        mungedPodSpec.SchedulingGates = oldPod.Spec.SchedulingGates // +k8s:verify-mutation:reason=clone
        // tolerations are checked before the deep copy, so munge those too
        mungedPodSpec.Tolerations = oldPod.Spec.Tolerations // +k8s:verify-mutation:reason=clone

        // Relax validation of immutable fields to allow it to be set to 1 if it was previously negative.
        if oldPod.Spec.TerminationGracePeriodSeconds != nil && *oldPod.Spec.TerminationGracePeriodSeconds < 0 &&
                mungedPodSpec.TerminationGracePeriodSeconds != nil && *mungedPodSpec.TerminationGracePeriodSeconds == 1 {
                mungedPodSpec.TerminationGracePeriodSeconds = oldPod.Spec.TerminationGracePeriodSeconds // +k8s:verify-mutation:reason=clone
        }

        // Handle validations specific to gated pods.
        podIsGated := len(oldPod.Spec.SchedulingGates) > 0
        if podIsGated {
                // Additions to spec.nodeSelector are allowed (no deletions or mutations) for gated pods.
                if !apiequality.Semantic.DeepEqual(mungedPodSpec.NodeSelector, oldPod.Spec.NodeSelector) {
                        allErrs = append(allErrs, validateNodeSelectorMutation(specPath.Child("nodeSelector"), mungedPodSpec.NodeSelector, oldPod.Spec.NodeSelector)...)
                        mungedPodSpec.NodeSelector = oldPod.Spec.NodeSelector // +k8s:verify-mutation:reason=clone
                }

                // Validate node affinity mutations.
                var oldNodeAffinity *core.NodeAffinity
                if oldPod.Spec.Affinity != nil {
                        oldNodeAffinity = oldPod.Spec.Affinity.NodeAffinity // +k8s:verify-mutation:reason=clone
                }

                var mungedNodeAffinity *core.NodeAffinity
                if mungedPodSpec.Affinity != nil {
                        mungedNodeAffinity = mungedPodSpec.Affinity.NodeAffinity // +k8s:verify-mutation:reason=clone
                }

                if !apiequality.Semantic.DeepEqual(oldNodeAffinity, mungedNodeAffinity) {
                        allErrs = append(allErrs, validateNodeAffinityMutation(specPath.Child("affinity").Child("nodeAffinity"), mungedNodeAffinity, oldNodeAffinity)...)
                        switch {
                        case mungedPodSpec.Affinity == nil && oldNodeAffinity == nil:
                                // already effectively nil, no change needed
                        case mungedPodSpec.Affinity == nil && oldNodeAffinity != nil:
                                mungedPodSpec.Affinity = &core.Affinity{NodeAffinity: oldNodeAffinity} // +k8s:verify-mutation:reason=clone
                        case mungedPodSpec.Affinity != nil && oldPod.Spec.Affinity == nil &&
                                mungedPodSpec.Affinity.PodAntiAffinity == nil && mungedPodSpec.Affinity.PodAffinity == nil:
                                // We ensure no other fields are being changed, but the NodeAffinity. If that's the case, and the
                                // old pod's affinity is nil, we set the mungedPodSpec's affinity to nil.
                                mungedPodSpec.Affinity = nil // +k8s:verify-mutation:reason=clone
                        default:
                                // The node affinity is being updated and the old pod Affinity is not nil.
                                // We set the mungedPodSpec's node affinity to the old pod's node affinity.
                                mungedPodSpec.Affinity.NodeAffinity = oldNodeAffinity // +k8s:verify-mutation:reason=clone
                        }
                }

                // Note: Unlike NodeAffinity and NodeSelector, we cannot make PodAffinity/PodAntiAffinity mutable due to the presence of the matchLabelKeys/mismatchLabelKeys feature.
                // Those features automatically generate the matchExpressions in labelSelector for PodAffinity/PodAntiAffinity when the Pod is created.
                // When we make them mutable, we need to make sure things like how to handle/validate matchLabelKeys,
                // and what if the fieldManager/A sets matchexpressions and fieldManager/B sets matchLabelKeys later. (could it lead the understandable conflict, etc)
        }

        if !apiequality.Semantic.DeepEqual(mungedPodSpec, oldPod.Spec) {
                // This diff isn't perfect, but it's a helluva lot better an "I'm not going to tell you what the difference is".
                // TODO: Pinpoint the specific field that causes the invalid error after we have strategic merge diff
                specDiff := diff.Diff(oldPod.Spec, mungedPodSpec)
                errs := field.Forbidden(specPath, fmt.Sprintf("pod updates may not change fields other than %s\n%v", strings.Join(updatablePodSpecFields, ","), specDiff))
                allErrs = append(allErrs, errs)
        }
        return allErrs
}

// ValidateContainerStateTransition test to if any illegal container state transitions are being attempted
func ValidateContainerStateTransition(newStatuses, oldStatuses []core.ContainerStatus, fldPath *field.Path, podSpec core.PodSpec) field.ErrorList {
        allErrs := field.ErrorList{}
        if utilfeature.DefaultFeatureGate.Enabled(features.ContainerRestartRules) {
                v1PodSpec := &v1.PodSpec{}
                err := corev1.Convert_core_PodSpec_To_v1_PodSpec(&podSpec, v1PodSpec, nil)
                if err != nil {
                        allErrs = append(allErrs, field.InternalError(fldPath, fmt.Errorf("invalid %q: %v", fldPath, err.Error())))
                }
                for i, oldStatus := range oldStatuses {
                        // Skip any container that is not terminated
                        if oldStatus.State.Terminated == nil {
                                continue
                        }
                        for _, newStatus := range newStatuses {
                                if newStatus.Name == oldStatus.Name && newStatus.State.Terminated == nil {
                                        allowed := false
                                        for _, c := range v1PodSpec.Containers {
                                                if c.Name == oldStatus.Name {
                                                        allowed = podutil.ContainerShouldRestart(c, *v1PodSpec, oldStatus.State.Terminated.ExitCode)
                                                        break
                                                }
                                        }
                                        if !allowed {
                                                allErrs = append(allErrs, field.Forbidden(fldPath.Index(i).Child("state"), "may not be transitioned to non-terminated state"))
                                        }
                                        break
                                }
                        }
                }
                return allErrs
        }
        restartPolicy := podSpec.RestartPolicy
        // If we should always restart, containers are allowed to leave the terminated state
        if restartPolicy == core.RestartPolicyAlways {
                return allErrs
        }
        for i, oldStatus := range oldStatuses {
                // Skip any container that is not terminated
                if oldStatus.State.Terminated == nil {
                        continue
                }
                // Skip any container that failed but is allowed to restart
                if oldStatus.State.Terminated.ExitCode != 0 && restartPolicy == core.RestartPolicyOnFailure {
                        continue
                }
                for _, newStatus := range newStatuses {
                        if oldStatus.Name == newStatus.Name && newStatus.State.Terminated == nil {
                                allErrs = append(allErrs, field.Forbidden(fldPath.Index(i).Child("state"), "may not be transitioned to non-terminated state"))
                        }
                }
        }
        return allErrs
}

// ValidateInitContainerStateTransition test to if any illegal init container state transitions are being attempted
func ValidateInitContainerStateTransition(newStatuses, oldStatuses []core.ContainerStatus, fldpath *field.Path, podSpec *core.PodSpec) field.ErrorList {
        allErrs := field.ErrorList{}
        // If we should always restart, containers are allowed to leave the terminated state
        if podSpec.RestartPolicy == core.RestartPolicyAlways {
                return allErrs
        }
        for i, oldStatus := range oldStatuses {
                // Skip any container that is not terminated
                if oldStatus.State.Terminated == nil {
                        continue
                }
                // Skip any container that failed but is allowed to restart
                if oldStatus.State.Terminated.ExitCode != 0 && podSpec.RestartPolicy == core.RestartPolicyOnFailure {
                        continue
                }

                // Skip any restartable init container that is allowed to restart
                isRestartableInitCtr := false
                for _, c := range podSpec.InitContainers {
                        if oldStatus.Name == c.Name {
                                if isRestartableInitContainer(&c) {
                                        isRestartableInitCtr = true
                                }
                                break
                        }
                }
                if isRestartableInitCtr {
                        continue
                }

                for _, newStatus := range newStatuses {
                        if oldStatus.Name == newStatus.Name && newStatus.State.Terminated == nil {
                                allErrs = append(allErrs, field.Forbidden(fldpath.Index(i).Child("state"), "may not be transitioned to non-terminated state"))
                        }
                }
        }
        return allErrs
}

// ValidateEphemeralContainerStateTransition test to if any ephemeral containers are transitioned
// from terminated state to non-terminated state.
func ValidateEphemeralContainerStateTransition(newStatuses, oldStatuses []core.ContainerStatus, fldpath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for i, oldStatus := range oldStatuses {
                // Skip any container that is not terminated
                if oldStatus.State.Terminated == nil {
                        continue
                }
                for _, newStatus := range newStatuses {
                        if oldStatus.Name == newStatus.Name && newStatus.State.Terminated == nil {
                                allErrs = append(allErrs, field.Forbidden(fldpath.Index(i).Child("state"), "may not be transitioned to non-terminated state"))
                        }
                }
        }
        return allErrs
}

// ValidatePodStatusUpdate checks for changes to status that shouldn't occur in normal operation.
func ValidatePodStatusUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) field.ErrorList {
        fldPath := field.NewPath("metadata")
        allErrs := ValidateObjectMetaUpdate(&newPod.ObjectMeta, &oldPod.ObjectMeta, fldPath)
        allErrs = append(allErrs, ValidatePodSpecificAnnotationUpdates(newPod, oldPod, fldPath.Child("annotations"), opts)...)

        fldPath = field.NewPath("status")
        allErrs = append(allErrs, validatePodConditions(newPod.Status.Conditions, fldPath.Child("conditions"))...)

        if newPod.Spec.NodeName != oldPod.Spec.NodeName {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("nodeName"), "may not be changed directly"))
        }

        if newPod.Status.NominatedNodeName != oldPod.Status.NominatedNodeName && len(newPod.Status.NominatedNodeName) > 0 {
                for _, msg := range ValidateNodeName(newPod.Status.NominatedNodeName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("nominatedNodeName"), newPod.Status.NominatedNodeName, msg))
                }
        }

        // Prevent setting NominatedNodeName on already bound pods
        if utilfeature.DefaultFeatureGate.Enabled(features.ClearingNominatedNodeNameAfterBinding) &&
                oldPod.Spec.NodeName != "" &&
                newPod.Status.NominatedNodeName != "" &&
                newPod.Status.NominatedNodeName != oldPod.Status.NominatedNodeName {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("nominatedNodeName"),
                        "may not be set on pods that are already bound to a node"))
        }

        if newPod.Status.ObservedGeneration < 0 {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("observedGeneration"), newPod.Status.ObservedGeneration, "must be a non-negative integer"))
        }

        // Pod QoS is immutable
        allErrs = append(allErrs, ValidateImmutableField(newPod.Status.QOSClass, oldPod.Status.QOSClass, fldPath.Child("qosClass"))...)

        // Note: there is no check that ContainerStatuses, InitContainerStatuses, and EphemeralContainerStatuses doesn't have duplicate conatainer names
        // or statuses of containers that are not defined in the pod spec. Changing this may lead to a breaking changes. So consumers of those fields
        // must account for unexpected data. Kubelet will never report statuses like this.
        //
        // If pod should not restart, make sure the status update does not transition
        // any terminated containers to a non-terminated state.
        allErrs = append(allErrs, ValidateContainerStateTransition(newPod.Status.ContainerStatuses, oldPod.Status.ContainerStatuses, fldPath.Child("containerStatuses"), oldPod.Spec)...)
        allErrs = append(allErrs, ValidateInitContainerStateTransition(newPod.Status.InitContainerStatuses, oldPod.Status.InitContainerStatuses, fldPath.Child("initContainerStatuses"), &oldPod.Spec)...)
        allErrs = append(allErrs, ValidateEphemeralContainerStateTransition(newPod.Status.EphemeralContainerStatuses, oldPod.Status.EphemeralContainerStatuses, fldPath.Child("ephemeralContainerStatuses"))...)
        allErrs = append(allErrs, validatePodResourceClaimStatuses(newPod.Status.ResourceClaimStatuses, newPod.Spec.ResourceClaims, fldPath.Child("resourceClaimStatuses"))...)
        allErrs = append(allErrs, validatePodExtendedResourceClaimStatus(newPod.Status.ExtendedResourceClaimStatus, &newPod.Spec, fldPath.Child("extendedResourceClaimStatus"))...)

        if newIPErrs := validatePodIPs(newPod, oldPod); len(newIPErrs) > 0 {
                allErrs = append(allErrs, newIPErrs...)
        }

        if newIPErrs := validateHostIPs(newPod, oldPod); len(newIPErrs) > 0 {
                allErrs = append(allErrs, newIPErrs...)
        }

        allErrs = append(allErrs, validateContainerStatusUsers(newPod.Status.ContainerStatuses, fldPath.Child("containerStatuses"), newPod.Spec.OS)...)
        allErrs = append(allErrs, validateContainerStatusUsers(newPod.Status.InitContainerStatuses, fldPath.Child("initContainerStatuses"), newPod.Spec.OS)...)
        allErrs = append(allErrs, validateContainerStatusUsers(newPod.Status.EphemeralContainerStatuses, fldPath.Child("ephemeralContainerStatuses"), newPod.Spec.OS)...)

        allErrs = append(allErrs, validateContainerStatusAllocatedResourcesStatus(newPod.Status.ContainerStatuses, fldPath.Child("containerStatuses"), newPod.Spec.Containers)...)
        allErrs = append(allErrs, validateContainerStatusAllocatedResourcesStatus(newPod.Status.InitContainerStatuses, fldPath.Child("initContainerStatuses"), newPod.Spec.InitContainers)...)
        // ephemeral containers are not allowed to have resources allocated
        allErrs = append(allErrs, validateContainerStatusNoAllocatedResourcesStatus(newPod.Status.EphemeralContainerStatuses, fldPath.Child("ephemeralContainerStatuses"))...)

        return allErrs
}

// validatePodConditions tests if the custom pod conditions are valid, and that the observedGeneration
// is a non-negative integer.
func validatePodConditions(conditions []core.PodCondition, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        systemConditions := sets.New(
                core.PodScheduled,
                core.PodReady,
                core.PodInitialized)
        for i, condition := range conditions {
                if condition.ObservedGeneration < 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("observedGeneration"), condition.ObservedGeneration, "must be a non-negative integer"))
                }
                if systemConditions.Has(condition.Type) {
                        continue
                }
                allErrs = append(allErrs, ValidateQualifiedName(string(condition.Type), fldPath.Index(i).Child("Type"))...)
        }
        return allErrs
}

// validatePodResourceClaimStatuses validates the ResourceClaimStatuses slice in a pod status.
func validatePodResourceClaimStatuses(statuses []core.PodResourceClaimStatus, podClaims []core.PodResourceClaim, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList

        claimNames := sets.New[string]()
        for i, status := range statuses {
                idxPath := fldPath.Index(i)
                // There's no need to check the content of the name. If it matches an entry,
                // then it is valid, otherwise we reject it here.
                if !havePodClaim(podClaims, status.Name) {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), status.Name, "must match the name of an entry in `spec.resourceClaims`"))
                }
                if claimNames.Has(status.Name) {
                        allErrs = append(allErrs, field.Duplicate(idxPath.Child("name"), status.Name))
                } else {
                        claimNames.Insert(status.Name)
                }
                if status.ResourceClaimName != nil {
                        for _, detail := range ValidateResourceClaimName(*status.ResourceClaimName, false) {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("name"), status.ResourceClaimName, detail))
                        }
                }
        }

        return allErrs
}

// validatePodExtendedResourceClaimStatus validates the ExtendedResourceClaimStatus in a pod status.
func validatePodExtendedResourceClaimStatus(status *core.PodExtendedResourceClaimStatus, spec *core.PodSpec, fldPath *field.Path) field.ErrorList {
        if status == nil {
                return nil
        }

        containers := make(map[string]*core.Container)
        for _, c := range spec.InitContainers {
                containers[c.Name] = &c
        }
        for _, c := range spec.Containers {
                containers[c.Name] = &c
        }

        var allErrs field.ErrorList
        rmFldPath := fldPath.Child("requestMappings")
        if len(status.RequestMappings) == 0 {
                allErrs = append(allErrs, field.Required(rmFldPath, "at least one request mapping is required"))
        }
        type key struct {
                container string
                resource  string
        }
        seen := map[key]struct{}{}
        for i, rm := range status.RequestMappings {
                idxPath := rmFldPath.Index(i)
                c, ok := containers[rm.ContainerName]
                if ok {
                        if _, ok := c.Resources.Requests[core.ResourceName(rm.ResourceName)]; !ok {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("resourceName"), rm.ResourceName, "must match the extended resource name of an entry in spec.initContainers.resources.requests or spec.containers.resources.requests"))
                        }
                } else {
                        allErrs = append(allErrs, field.Invalid(idxPath.Child("containerName"), rm.ContainerName, "must match the name of an entry in spec.initContainers.name or spec.containers.name"))
                }
                allErrs = append(allErrs, ValidateDNS1123Label(rm.RequestName, fldPath.Child("requestName"))...)
                k := key{container: rm.ContainerName, resource: rm.ResourceName}
                if _, ok := seen[k]; ok {
                        allErrs = append(allErrs, field.Duplicate(idxPath.Child("containerName"), rm.ContainerName))
                        allErrs = append(allErrs, field.Duplicate(idxPath.Child("resourceName"), rm.ResourceName))
                }
                seen[k] = struct{}{}
        }
        if len(status.ResourceClaimName) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("resourceClaimName"), ""))
        } else {
                for _, detail := range ValidateResourceClaimName(status.ResourceClaimName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("resourceClaimName"), status.ResourceClaimName, detail))
                }
        }
        return allErrs
}

func havePodClaim(podClaims []core.PodResourceClaim, name string) bool {
        for _, podClaim := range podClaims {
                if podClaim.Name == name {
                        return true
                }
        }
        return false
}

// ValidatePodEphemeralContainersUpdate tests that a user update to EphemeralContainers is valid.
// newPod and oldPod must only differ in their EphemeralContainers.
func ValidatePodEphemeralContainersUpdate(newPod, oldPod *core.Pod, opts PodValidationOptions) field.ErrorList {
        // Part 1: Validate newPod's spec and updates to metadata
        fldPath := field.NewPath("metadata")
        allErrs := ValidateObjectMetaUpdate(&newPod.ObjectMeta, &oldPod.ObjectMeta, fldPath)
        allErrs = append(allErrs, validatePodMetadataAndSpec(newPod, opts)...)
        allErrs = append(allErrs, ValidatePodSpecificAnnotationUpdates(newPod, oldPod, fldPath.Child("annotations"), opts)...)

        // static pods don't support ephemeral containers #113935
        if _, ok := oldPod.Annotations[core.MirrorPodAnnotationKey]; ok {
                return field.ErrorList{field.Forbidden(field.NewPath(""), "static pods do not support ephemeral containers")}
        }

        // Part 2: Validate that the changes between oldPod.Spec.EphemeralContainers and
        // newPod.Spec.EphemeralContainers are allowed.
        //
        // Existing EphemeralContainers may not be changed. Order isn't preserved by patch, so check each individually.
        newContainerIndex := make(map[string]*core.EphemeralContainer)
        specPath := field.NewPath("spec").Child("ephemeralContainers")
        for i := range newPod.Spec.EphemeralContainers {
                newContainerIndex[newPod.Spec.EphemeralContainers[i].Name] = &newPod.Spec.EphemeralContainers[i]
        }
        for _, old := range oldPod.Spec.EphemeralContainers {
                if new, ok := newContainerIndex[old.Name]; !ok {
                        allErrs = append(allErrs, field.Forbidden(specPath, fmt.Sprintf("existing ephemeral containers %q may not be removed\n", old.Name)))
                } else if !apiequality.Semantic.DeepEqual(old, *new) {
                        specDiff := diff.Diff(old, *new)
                        allErrs = append(allErrs, field.Forbidden(specPath, fmt.Sprintf("existing ephemeral containers %q may not be changed\n%v", old.Name, specDiff)))
                }
        }

        return allErrs
}

// ValidatePodResize tests that a user update to pod container resources is valid.
// newPod and oldPod must only differ in their Containers[*].Resources and
// Containers[*].ResizePolicy field.
func ValidatePodResize(newPod, oldPod *core.Pod, opts PodValidationOptions) field.ErrorList {
        // Part 1: Validate newPod's spec and updates to metadata
        fldPath := field.NewPath("metadata")
        allErrs := ValidateObjectMetaUpdate(&newPod.ObjectMeta, &oldPod.ObjectMeta, fldPath)
        allErrs = append(allErrs, validatePodMetadataAndSpec(newPod, opts)...)

        // pods with pod-level resources cannot be resized
        isPodLevelResourcesSet := func(pod *core.Pod) bool {
                return pod.Spec.Resources != nil &&
                        (len(pod.Spec.Resources.Requests)+len(pod.Spec.Resources.Limits) > 0)
        }

        if isPodLevelResourcesSet(oldPod) || isPodLevelResourcesSet(newPod) {
                return field.ErrorList{field.Forbidden(field.NewPath(""), "pods with pod-level resources cannot be resized")}
        }

        // static pods cannot be resized.
        if _, ok := oldPod.Annotations[core.MirrorPodAnnotationKey]; ok {
                return field.ErrorList{field.Forbidden(field.NewPath(""), "static pods cannot be resized")}
        }

        // windows pods are not supported.
        if oldPod.Spec.OS != nil && oldPod.Spec.OS.Name == core.Windows {
                return field.ErrorList{field.Forbidden(field.NewPath(""), "windows pods cannot be resized")}
        }

        // Part 2: Validate that the changes between oldPod.Spec.Containers[].Resources and
        // newPod.Spec.Containers[].Resources are allowed. Also validate that the changes between oldPod.Spec.InitContainers[].Resources and
        // newPod.Spec.InitContainers[].Resources are allowed.
        specPath := field.NewPath("spec")
        if qos.GetPodQOS(oldPod) != qos.ComputePodQOS(newPod) {
                allErrs = append(allErrs, field.Invalid(specPath, newPod.Status.QOSClass, "Pod QOS Class may not change as a result of resizing"))
        }

        if !isPodResizeRequestSupported(*oldPod) {
                allErrs = append(allErrs, field.Forbidden(specPath, "Pod running on node without support for resize"))
        }

        // The rest of the validation assumes that the containers are in the same order,
        // so we proceed only if that assumption is true.
        containerOrderErrs := validatePodResizeContainerOrdering(newPod, oldPod, specPath)
        allErrs = append(allErrs, containerOrderErrs...)
        if containerOrderErrs != nil {
                return allErrs
        }

        // Do not allow removing resource requests/limits on resize.
        if utilfeature.DefaultFeatureGate.Enabled(features.SidecarContainers) {
                for ix, ctr := range oldPod.Spec.InitContainers {
                        if !isRestartableInitContainer(&ctr) {
                                continue
                        }
                        allErrs = append(allErrs, validateContainerResize(
                                &newPod.Spec.InitContainers[ix].Resources,
                                &oldPod.Spec.InitContainers[ix].Resources,
                                newPod.Spec.InitContainers[ix].ResizePolicy,
                                specPath.Child("initContainers").Index(ix).Child("resources"))...)
                }
        }
        for ix := range oldPod.Spec.Containers {
                allErrs = append(allErrs, validateContainerResize(
                        &newPod.Spec.Containers[ix].Resources,
                        &oldPod.Spec.Containers[ix].Resources,
                        newPod.Spec.Containers[ix].ResizePolicy,
                        specPath.Child("containers").Index(ix).Child("resources"))...)
        }

        // Ensure that only CPU and memory resources are mutable for regular containers.
        originalCPUMemPodSpec := *newPod.Spec.DeepCopy()
        var newContainers []core.Container
        for ix, container := range originalCPUMemPodSpec.Containers {
                dropCPUMemoryResourcesFromContainer(&container, &oldPod.Spec.Containers[ix])
                if !apiequality.Semantic.DeepEqual(container, oldPod.Spec.Containers[ix]) {
                        // This likely means that the user has made changes to resources other than CPU and memory for regular container.
                        errs := field.Forbidden(specPath, "only cpu and memory resources are mutable")
                        allErrs = append(allErrs, errs)
                }
                newContainers = append(newContainers, container)
        }
        originalCPUMemPodSpec.Containers = newContainers

        // Ensure that only CPU and memory resources are mutable for restartable init containers.
        // Also ensure that resources are immutable for non-restartable init containers.
        var newInitContainers []core.Container
        if utilfeature.DefaultFeatureGate.Enabled(features.SidecarContainers) {
                for ix, container := range originalCPUMemPodSpec.InitContainers {
                        if isRestartableInitContainer(&container) { // restartable init container
                                dropCPUMemoryResourcesFromContainer(&container, &oldPod.Spec.InitContainers[ix])
                                if !apiequality.Semantic.DeepEqual(container, oldPod.Spec.InitContainers[ix]) {
                                        // This likely means that the user has made changes to resources other than CPU and memory for sidecar container.
                                        errs := field.Forbidden(specPath, "only cpu and memory resources for sidecar containers are mutable")
                                        allErrs = append(allErrs, errs)
                                }
                        } else if !apiequality.Semantic.DeepEqual(container, oldPod.Spec.InitContainers[ix]) { // non-restartable init container
                                // This likely means that the user has modified resources of non-sidecar init container.
                                errs := field.Forbidden(specPath, "resources for non-sidecar init containers are immutable")
                                allErrs = append(allErrs, errs)
                        }
                        newInitContainers = append(newInitContainers, container)
                }
                originalCPUMemPodSpec.InitContainers = newInitContainers
        }

        if len(allErrs) > 0 {
                return allErrs
        }

        if !apiequality.Semantic.DeepEqual(originalCPUMemPodSpec, oldPod.Spec) {
                // This likely means that the user has made changes to resources other than CPU and Memory.
                errs := field.Forbidden(specPath, "only cpu and memory resources are mutable")
                allErrs = append(allErrs, errs)
        }
        return allErrs
}

// validatePodResizeContainerOrdering validates container ordering for a resize request.
// We do not allow adding, removing, re-ordering, or renaming containers on resize.
func validatePodResizeContainerOrdering(newPod, oldPod *core.Pod, specPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        if len(newPod.Spec.Containers) != len(oldPod.Spec.Containers) {
                allErrs = append(allErrs, field.Forbidden(specPath.Child("containers"), "containers may not be added or removed on resize"))
        } else {
                for i, oldCtr := range oldPod.Spec.Containers {
                        if newPod.Spec.Containers[i].Name != oldCtr.Name {
                                allErrs = append(allErrs, field.Forbidden(specPath.Child("containers").Index(i).Child("name"), "containers may not be renamed or reordered on resize"))
                        }
                }
        }
        if len(newPod.Spec.InitContainers) != len(oldPod.Spec.InitContainers) {
                allErrs = append(allErrs, field.Forbidden(specPath.Child("initContainers"), "initContainers may not be added or removed on resize"))
        } else {
                for i, oldCtr := range oldPod.Spec.InitContainers {
                        if newPod.Spec.InitContainers[i].Name != oldCtr.Name {
                                allErrs = append(allErrs, field.Forbidden(specPath.Child("initContainers").Index(i).Child("name"), "initContainers may not be renamed or reordered on resize"))
                        }
                }
        }
        return allErrs
}

// dropCPUMemoryResourcesFromContainer deletes the cpu and memory resources from the container, and copies them from the old pod container resources if present.
func dropCPUMemoryResourcesFromContainer(container *core.Container, oldPodSpecContainer *core.Container) {
        dropCPUMemoryUpdates := func(resourceList, oldResourceList core.ResourceList) core.ResourceList {
                if oldResourceList == nil {
                        return nil
                }
                var mungedResourceList core.ResourceList
                if resourceList == nil {
                        mungedResourceList = make(core.ResourceList)
                } else {
                        mungedResourceList = resourceList.DeepCopy()
                }
                delete(mungedResourceList, core.ResourceCPU)
                delete(mungedResourceList, core.ResourceMemory)
                if cpu, found := oldResourceList[core.ResourceCPU]; found {
                        mungedResourceList[core.ResourceCPU] = cpu
                }
                if mem, found := oldResourceList[core.ResourceMemory]; found {
                        mungedResourceList[core.ResourceMemory] = mem
                }
                return mungedResourceList
        }
        lim := dropCPUMemoryUpdates(container.Resources.Limits, oldPodSpecContainer.Resources.Limits)
        req := dropCPUMemoryUpdates(container.Resources.Requests, oldPodSpecContainer.Resources.Requests)
        container.Resources = core.ResourceRequirements{Limits: lim, Requests: req}
}

// isPodResizeRequestSupported checks whether the pod is running on a node with InPlacePodVerticalScaling enabled.
func isPodResizeRequestSupported(pod core.Pod) bool {
        // TODO: Remove this after GA+3 releases of InPlacePodVerticalScaling
        // This code handles the version skew as described in the KEP.
        // For handling version skew we're only allowing to update the Pod's Resources
        // if the Pod already has Pod.Status.ContainerStatuses[i].Resources. This means
        // that the apiserver would only allow updates to Pods running on Nodes with
        // the InPlacePodVerticalScaling feature gate enabled.
        for _, c := range pod.Status.ContainerStatuses {
                if c.State.Running != nil {
                        return c.Resources != nil
                }
        }
        // No running containers. We cannot tell whether the node supports resize at this point, so we assume it does.
        return true
}

// validateContainerResize validates the changes to the container's resource requirements for a pod resize request.
// newRequriements and oldRequirements must be non-nil.
func validateContainerResize(newRequirements, oldRequirements *core.ResourceRequirements, resizePolicies []core.ContainerResizePolicy, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList

        // Removing resource requirements is not supported.
        if resourcesRemoved(newRequirements.Requests, oldRequirements.Requests) {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("requests"), "resource requests cannot be removed"))
        }
        if resourcesRemoved(newRequirements.Limits, oldRequirements.Limits) {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("limits"), "resource limits cannot be removed"))
        }

        // TODO(tallclair): Move resizable resource checks here.

        return allErrs
}

func resourcesRemoved(resourceList, oldResourceList core.ResourceList) bool {
        if len(oldResourceList) > len(resourceList) {
                return true
        }
        for name := range oldResourceList {
                if _, ok := resourceList[name]; !ok {
                        return true
                }
        }

        return false
}

// ValidatePodBinding tests if required fields in the pod binding are legal.
func ValidatePodBinding(binding *core.Binding) field.ErrorList {
        allErrs := field.ErrorList{}

        if len(binding.Target.Kind) != 0 && binding.Target.Kind != "Node" {
                // TODO: When validation becomes versioned, this gets more complicated.
                allErrs = append(allErrs, field.NotSupported(field.NewPath("target", "kind"), binding.Target.Kind, []string{"Node", "<empty>"}))
        }
        if len(binding.Target.Name) == 0 {
                // TODO: When validation becomes versioned, this gets more complicated.
                allErrs = append(allErrs, field.Required(field.NewPath("target", "name"), ""))
        }

        return allErrs
}

// ValidatePodTemplate tests if required fields in the pod template are set.
func ValidatePodTemplate(pod *core.PodTemplate, opts PodValidationOptions) field.ErrorList {
        allErrs := ValidateObjectMeta(&pod.ObjectMeta, true, ValidatePodName, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidatePodTemplateSpec(&pod.Template, field.NewPath("template"), opts)...)
        return allErrs
}

// ValidatePodTemplateUpdate tests to see if the update is legal for an end user to make. newPod is updated with fields
// that cannot be changed.
func ValidatePodTemplateUpdate(newPod, oldPod *core.PodTemplate, opts PodValidationOptions) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newPod.ObjectMeta, &oldPod.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidatePodTemplateSpec(&newPod.Template, field.NewPath("template"), opts)...)
        return allErrs
}

var supportedSessionAffinityType = sets.New(core.ServiceAffinityClientIP, core.ServiceAffinityNone)
var supportedServiceType = sets.New(core.ServiceTypeClusterIP, core.ServiceTypeNodePort,
        core.ServiceTypeLoadBalancer, core.ServiceTypeExternalName)

var supportedServiceInternalTrafficPolicy = sets.New(core.ServiceInternalTrafficPolicyCluster, core.ServiceInternalTrafficPolicyLocal)

var supportedServiceIPFamily = sets.New(core.IPv4Protocol, core.IPv6Protocol)
var supportedServiceIPFamilyPolicy = sets.New(
        core.IPFamilyPolicySingleStack,
        core.IPFamilyPolicyPreferDualStack,
        core.IPFamilyPolicyRequireDualStack)

// ValidateService tests if required fields/annotations of a Service are valid.
func validateService(service, oldService *core.Service) field.ErrorList {
        metaPath := field.NewPath("metadata")

        // Don't validate ObjectMeta here - that is handled in the ValidateServiceCreate/ValidateServiceUpdate
        // functions which call ValidateObjectMeta and ValidateObjectMetaUpdate respectively.
        var allErrs field.ErrorList

        topologyHintsVal, topologyHintsSet := service.Annotations[core.DeprecatedAnnotationTopologyAwareHints]
        topologyModeVal, topologyModeSet := service.Annotations[core.AnnotationTopologyMode]

        if topologyModeSet && topologyHintsSet && topologyModeVal != topologyHintsVal {
                message := fmt.Sprintf("must match annotations[%s] when both are specified", core.DeprecatedAnnotationTopologyAwareHints)
                allErrs = append(allErrs, field.Invalid(metaPath.Child("annotations").Key(core.AnnotationTopologyMode), topologyModeVal, message))
        }

        specPath := field.NewPath("spec")

        if len(service.Spec.Ports) == 0 && !isHeadlessService(service) && service.Spec.Type != core.ServiceTypeExternalName {
                allErrs = append(allErrs, field.Required(specPath.Child("ports"), ""))
        }
        switch service.Spec.Type {
        case core.ServiceTypeLoadBalancer:
                if isHeadlessService(service) {
                        allErrs = append(allErrs, field.Invalid(specPath.Child("clusterIPs").Index(0), service.Spec.ClusterIPs[0], "may not be set to 'None' for LoadBalancer services"))
                }
        case core.ServiceTypeNodePort:
                if isHeadlessService(service) {
                        allErrs = append(allErrs, field.Invalid(specPath.Child("clusterIPs").Index(0), service.Spec.ClusterIPs[0], "may not be set to 'None' for NodePort services"))
                }
        case core.ServiceTypeExternalName:
                // must have  len(.spec.ClusterIPs) == 0 // note: strategy sets ClusterIPs based on ClusterIP
                if len(service.Spec.ClusterIPs) > 0 {
                        allErrs = append(allErrs, field.Forbidden(specPath.Child("clusterIPs"), "may not be set for ExternalName services"))
                }

                // must have nil families and nil policy
                if len(service.Spec.IPFamilies) > 0 {
                        allErrs = append(allErrs, field.Forbidden(specPath.Child("ipFamilies"), "may not be set for ExternalName services"))
                }
                if service.Spec.IPFamilyPolicy != nil {
                        allErrs = append(allErrs, field.Forbidden(specPath.Child("ipFamilyPolicy"), "may not be set for ExternalName services"))
                }

                // The value (a CNAME) may have a trailing dot to denote it as fully qualified
                cname := strings.TrimSuffix(service.Spec.ExternalName, ".")
                if len(cname) > 0 {
                        allErrs = append(allErrs, ValidateDNS1123Subdomain(cname, specPath.Child("externalName"))...)
                } else {
                        allErrs = append(allErrs, field.Required(specPath.Child("externalName"), ""))
                }
        }

        allPortNames := sets.Set[string]{}
        portsPath := specPath.Child("ports")
        for i := range service.Spec.Ports {
                portPath := portsPath.Index(i)
                allErrs = append(allErrs, validateServicePort(&service.Spec.Ports[i], len(service.Spec.Ports) > 1, isHeadlessService(service), &allPortNames, portPath)...)
        }

        if service.Spec.Selector != nil {
                allErrs = append(allErrs, unversionedvalidation.ValidateLabels(service.Spec.Selector, specPath.Child("selector"))...)
        }

        if len(service.Spec.SessionAffinity) == 0 {
                allErrs = append(allErrs, field.Required(specPath.Child("sessionAffinity"), ""))
        } else if !supportedSessionAffinityType.Has(service.Spec.SessionAffinity) {
                allErrs = append(allErrs, field.NotSupported(specPath.Child("sessionAffinity"), service.Spec.SessionAffinity, sets.List(supportedSessionAffinityType)))
        }

        if service.Spec.SessionAffinity == core.ServiceAffinityClientIP {
                allErrs = append(allErrs, validateClientIPAffinityConfig(service.Spec.SessionAffinityConfig, specPath.Child("sessionAffinityConfig"))...)
        } else if service.Spec.SessionAffinity == core.ServiceAffinityNone {
                if service.Spec.SessionAffinityConfig != nil {
                        allErrs = append(allErrs, field.Forbidden(specPath.Child("sessionAffinityConfig"), fmt.Sprintf("must not be set when session affinity is %s", core.ServiceAffinityNone)))
                }
        }

        // dualstack <-> ClusterIPs <-> ipfamilies
        allErrs = append(allErrs, ValidateServiceClusterIPsRelatedFields(service, oldService)...)

        // All new ExternalIPs must be valid and "non-special". (Existing ExternalIPs may
        // have been validated against older rules, but if we allowed them before we can't
        // reject them now.)
        ipPath := specPath.Child("externalIPs")
        var existingExternalIPs []string
        if oldService != nil {
                existingExternalIPs = oldService.Spec.ExternalIPs // +k8s:verify-mutation:reason=clone
        }
        for i, ip := range service.Spec.ExternalIPs {
                idxPath := ipPath.Index(i)
                if errs := IsValidIPForLegacyField(idxPath, ip, existingExternalIPs); len(errs) != 0 {
                        allErrs = append(allErrs, errs...)
                } else {
                        // For historical reasons, this uses ValidateEndpointIP even
                        // though that is not exactly the appropriate set of checks.
                        allErrs = append(allErrs, ValidateEndpointIP(ip, idxPath)...)
                }
        }

        if len(service.Spec.Type) == 0 {
                allErrs = append(allErrs, field.Required(specPath.Child("type"), ""))
        } else if !supportedServiceType.Has(service.Spec.Type) {
                allErrs = append(allErrs, field.NotSupported(specPath.Child("type"), service.Spec.Type, sets.List(supportedServiceType)))
        }

        if service.Spec.Type == core.ServiceTypeClusterIP {
                portsPath := specPath.Child("ports")
                for i := range service.Spec.Ports {
                        portPath := portsPath.Index(i)
                        if service.Spec.Ports[i].NodePort != 0 {
                                allErrs = append(allErrs, field.Forbidden(portPath.Child("nodePort"), "may not be used when `type` is 'ClusterIP'"))
                        }
                }
        }

        // Check for duplicate NodePorts, considering (protocol,port) pairs
        portsPath = specPath.Child("ports")
        nodePorts := make(map[core.ServicePort]bool)
        for i := range service.Spec.Ports {
                port := &service.Spec.Ports[i]
                if port.NodePort == 0 {
                        continue
                }
                portPath := portsPath.Index(i)
                var key core.ServicePort
                key.Protocol = port.Protocol
                key.NodePort = port.NodePort
                _, found := nodePorts[key]
                if found {
                        allErrs = append(allErrs, field.Duplicate(portPath.Child("nodePort"), port.NodePort))
                }
                nodePorts[key] = true
        }

        // Check for duplicate Ports, considering (protocol,port) pairs
        portsPath = specPath.Child("ports")
        ports := make(map[core.ServicePort]bool)
        for i, port := range service.Spec.Ports {
                portPath := portsPath.Index(i)
                key := core.ServicePort{Protocol: port.Protocol, Port: port.Port}
                _, found := ports[key]
                if found {
                        allErrs = append(allErrs, field.Duplicate(portPath, key))
                }
                ports[key] = true
        }

        // Validate SourceRanges field or annotation. Existing invalid CIDR values do not
        // need to be fixed. Note that even with the tighter CIDR validation we still
        // allow excess whitespace, because that is effectively part of the API.
        if len(service.Spec.LoadBalancerSourceRanges) > 0 {
                fieldPath := specPath.Child("LoadBalancerSourceRanges")

                if service.Spec.Type != core.ServiceTypeLoadBalancer {
                        allErrs = append(allErrs, field.Forbidden(fieldPath, "may only be used when `type` is 'LoadBalancer'"))
                }
                var existingSourceRanges []string
                if oldService != nil {
                        existingSourceRanges = make([]string, len(oldService.Spec.LoadBalancerSourceRanges))
                        for i, value := range oldService.Spec.LoadBalancerSourceRanges {
                                existingSourceRanges[i] = strings.TrimSpace(value)
                        }
                }
                for idx, value := range service.Spec.LoadBalancerSourceRanges {
                        // Note: due to a historical accident around transition from the
                        // annotation value, these values are allowed to be space-padded.
                        value = strings.TrimSpace(value)
                        allErrs = append(allErrs, IsValidCIDRForLegacyField(fieldPath.Index(idx), value, existingSourceRanges)...)
                }
        } else if val, annotationSet := service.Annotations[core.AnnotationLoadBalancerSourceRangesKey]; annotationSet {
                fieldPath := field.NewPath("metadata", "annotations").Key(core.AnnotationLoadBalancerSourceRangesKey)
                if service.Spec.Type != core.ServiceTypeLoadBalancer {
                        allErrs = append(allErrs, field.Forbidden(fieldPath, "may only be used when `type` is 'LoadBalancer'"))
                }

                if oldService == nil || oldService.Annotations[core.AnnotationLoadBalancerSourceRangesKey] != val {
                        val = strings.TrimSpace(val)
                        if val != "" {
                                cidrs := strings.Split(val, ",")
                                for _, value := range cidrs {
                                        value = strings.TrimSpace(value)
                                        allErrs = append(allErrs, IsValidCIDRForLegacyField(fieldPath, value, nil)...)
                                }
                        }
                }
        }

        if service.Spec.AllocateLoadBalancerNodePorts != nil && service.Spec.Type != core.ServiceTypeLoadBalancer {
                allErrs = append(allErrs, field.Forbidden(specPath.Child("allocateLoadBalancerNodePorts"), "may only be used when `type` is 'LoadBalancer'"))
        }

        if service.Spec.Type == core.ServiceTypeLoadBalancer && service.Spec.AllocateLoadBalancerNodePorts == nil {
                allErrs = append(allErrs, field.Required(field.NewPath("allocateLoadBalancerNodePorts"), ""))
        }

        // validate LoadBalancerClass field
        allErrs = append(allErrs, validateLoadBalancerClassField(nil, service)...)

        // external traffic policy fields
        allErrs = append(allErrs, validateServiceExternalTrafficPolicy(service)...)

        // internal traffic policy field
        allErrs = append(allErrs, validateServiceInternalTrafficFieldsValue(service)...)

        // traffic distribution field
        allErrs = append(allErrs, validateServiceTrafficDistribution(service)...)

        return allErrs
}

func validateServicePort(sp *core.ServicePort, requireName, isHeadlessService bool, allNames *sets.Set[string], fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if requireName && len(sp.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        } else if len(sp.Name) != 0 {
                allErrs = append(allErrs, ValidateDNS1123Label(sp.Name, fldPath.Child("name"))...)
                if allNames.Has(sp.Name) {
                        allErrs = append(allErrs, field.Duplicate(fldPath.Child("name"), sp.Name))
                } else {
                        allNames.Insert(sp.Name)
                }
        }

        for _, msg := range validation.IsValidPortNum(int(sp.Port)) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("port"), sp.Port, msg))
        }

        if len(sp.Protocol) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("protocol"), ""))
        } else if !supportedPortProtocols.Has(sp.Protocol) {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("protocol"), sp.Protocol, sets.List(supportedPortProtocols)))
        }

        allErrs = append(allErrs, ValidatePortNumOrName(sp.TargetPort, fldPath.Child("targetPort"))...)

        if sp.AppProtocol != nil {
                allErrs = append(allErrs, ValidateQualifiedName(*sp.AppProtocol, fldPath.Child("appProtocol"))...)
        }

        // in the v1 API, targetPorts on headless services were tolerated.
        // once we have version-specific validation, we can reject this on newer API versions, but until then, we have to tolerate it for compatibility.
        //
        // if isHeadlessService {
        //         if sp.TargetPort.Type == intstr.String || (sp.TargetPort.Type == intstr.Int && sp.Port != sp.TargetPort.IntValue()) {
        //                 allErrs = append(allErrs, field.Invalid(fldPath.Child("targetPort"), sp.TargetPort, "must be equal to the value of 'port' when clusterIP = None"))
        //         }
        // }

        return allErrs
}

var validExternalTrafficPolicies = sets.New(core.ServiceExternalTrafficPolicyCluster, core.ServiceExternalTrafficPolicyLocal)

func validateServiceExternalTrafficPolicy(service *core.Service) field.ErrorList {
        allErrs := field.ErrorList{}

        fldPath := field.NewPath("spec")

        if !apiservice.ExternallyAccessible(service) {
                if service.Spec.ExternalTrafficPolicy != "" {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("externalTrafficPolicy"), service.Spec.ExternalTrafficPolicy,
                                "may only be set for externally-accessible services"))
                }
        } else {
                if service.Spec.ExternalTrafficPolicy == "" {
                        allErrs = append(allErrs, field.Required(fldPath.Child("externalTrafficPolicy"), ""))
                } else if !validExternalTrafficPolicies.Has(service.Spec.ExternalTrafficPolicy) {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("externalTrafficPolicy"),
                                service.Spec.ExternalTrafficPolicy, sets.List(validExternalTrafficPolicies)))
                }
        }

        if !apiservice.NeedsHealthCheck(service) {
                if service.Spec.HealthCheckNodePort != 0 {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("healthCheckNodePort"), service.Spec.HealthCheckNodePort,
                                "may only be set when `type` is 'LoadBalancer' and `externalTrafficPolicy` is 'Local'"))
                }
        } else {
                if service.Spec.HealthCheckNodePort == 0 {
                        allErrs = append(allErrs, field.Required(fldPath.Child("healthCheckNodePort"), ""))
                } else {
                        for _, msg := range validation.IsValidPortNum(int(service.Spec.HealthCheckNodePort)) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("healthCheckNodePort"), service.Spec.HealthCheckNodePort, msg))
                        }
                }
        }

        return allErrs
}

func validateServiceExternalTrafficFieldsUpdate(before, after *core.Service) field.ErrorList {
        allErrs := field.ErrorList{}

        if apiservice.NeedsHealthCheck(before) && apiservice.NeedsHealthCheck(after) {
                if after.Spec.HealthCheckNodePort != before.Spec.HealthCheckNodePort {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "healthCheckNodePort"), "field is immutable"))
                }
        }

        return allErrs
}

// validateServiceInternalTrafficFieldsValue validates InternalTraffic related
// spec have legal value.
func validateServiceInternalTrafficFieldsValue(service *core.Service) field.ErrorList {
        allErrs := field.ErrorList{}

        if service.Spec.InternalTrafficPolicy == nil {
                // We do not forbid internalTrafficPolicy on other Service types because of historical reasons.
                // We did not check that before it went beta and we don't want to invalidate existing stored objects.
                if service.Spec.Type == core.ServiceTypeNodePort ||
                        service.Spec.Type == core.ServiceTypeLoadBalancer || service.Spec.Type == core.ServiceTypeClusterIP {
                        allErrs = append(allErrs, field.Required(field.NewPath("spec").Child("internalTrafficPolicy"), ""))
                }
        }

        if service.Spec.InternalTrafficPolicy != nil && !supportedServiceInternalTrafficPolicy.Has(*service.Spec.InternalTrafficPolicy) {
                allErrs = append(allErrs, field.NotSupported(field.NewPath("spec").Child("internalTrafficPolicy"), *service.Spec.InternalTrafficPolicy, sets.List(supportedServiceInternalTrafficPolicy)))
        }

        return allErrs
}

// validateServiceTrafficDistribution validates the values for the
// trafficDistribution field.
func validateServiceTrafficDistribution(service *core.Service) field.ErrorList {
        allErrs := field.ErrorList{}

        if service.Spec.TrafficDistribution == nil {
                return allErrs
        }

        var supportedTrafficDistribution []string
        if !utilfeature.DefaultFeatureGate.Enabled(features.PreferSameTrafficDistribution) {
                supportedTrafficDistribution = []string{
                        v1.ServiceTrafficDistributionPreferClose,
                }
        } else {
                supportedTrafficDistribution = []string{
                        v1.ServiceTrafficDistributionPreferClose,
                        v1.ServiceTrafficDistributionPreferSameZone,
                        v1.ServiceTrafficDistributionPreferSameNode,
                }
        }

        if !slices.Contains(supportedTrafficDistribution, *service.Spec.TrafficDistribution) {
                allErrs = append(allErrs, field.NotSupported(field.NewPath("spec").Child("trafficDistribution"), *service.Spec.TrafficDistribution, supportedTrafficDistribution))
        }

        return allErrs
}

// ValidateServiceCreate validates Services as they are created.
func ValidateServiceCreate(service *core.Service) field.ErrorList {
        metaPath := field.NewPath("metadata")

        // KEP-5311 Relaxed validation for Services names
        validateServiceNameFunc := ValidateServiceName
        if utilfeature.DefaultFeatureGate.Enabled(features.RelaxedServiceNameValidation) {
                validateServiceNameFunc = apimachineryvalidation.NameIsDNSLabel
        }

        allErrs := ValidateObjectMeta(&service.ObjectMeta, true, validateServiceNameFunc, metaPath)

        return append(allErrs, validateService(service, nil)...)
}

// ValidateServiceUpdate tests if required fields in the service are set during an update
func ValidateServiceUpdate(service, oldService *core.Service) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&service.ObjectMeta, &oldService.ObjectMeta, field.NewPath("metadata"))

        // User can upgrade (add another clusterIP or ipFamily)
        //      can downgrade (remove secondary clusterIP or ipFamily)
        // but *CAN NOT* change primary/secondary clusterIP || ipFamily *UNLESS*
        // they are changing from/to/ON ExternalName

        upgradeDowngradeClusterIPsErrs := validateUpgradeDowngradeClusterIPs(oldService, service)
        allErrs = append(allErrs, upgradeDowngradeClusterIPsErrs...)

        upgradeDowngradeIPFamiliesErrs := validateUpgradeDowngradeIPFamilies(oldService, service)
        allErrs = append(allErrs, upgradeDowngradeIPFamiliesErrs...)

        upgradeDowngradeLoadBalancerClassErrs := validateLoadBalancerClassField(oldService, service)
        allErrs = append(allErrs, upgradeDowngradeLoadBalancerClassErrs...)

        allErrs = append(allErrs, validateServiceExternalTrafficFieldsUpdate(oldService, service)...)

        return append(allErrs, validateService(service, oldService)...)
}

// ValidateServiceStatusUpdate tests if required fields in the Service are set when updating status.
func ValidateServiceStatusUpdate(service, oldService *core.Service) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&service.ObjectMeta, &oldService.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateLoadBalancerStatus(&service.Status.LoadBalancer, &oldService.Status.LoadBalancer, field.NewPath("status", "loadBalancer"), &service.Spec)...)
        return allErrs
}

// ValidateReplicationController tests if required fields in the replication controller are set.
func ValidateReplicationController(controller *core.ReplicationController, opts PodValidationOptions) field.ErrorList {
        allErrs := ValidateObjectMeta(&controller.ObjectMeta, true, ValidateReplicationControllerName, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateReplicationControllerSpec(&controller.Spec, nil, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateReplicationControllerUpdate tests if required fields in the replication controller are set.
func ValidateReplicationControllerUpdate(controller, oldController *core.ReplicationController, opts PodValidationOptions) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&controller.ObjectMeta, &oldController.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateReplicationControllerSpec(&controller.Spec, &oldController.Spec, field.NewPath("spec"), opts)...)
        return allErrs
}

// ValidateReplicationControllerStatusUpdate tests if required fields in the replication controller are set.
func ValidateReplicationControllerStatusUpdate(controller, oldController *core.ReplicationController) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&controller.ObjectMeta, &oldController.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateReplicationControllerStatus(controller.Status, field.NewPath("status"))...)
        return allErrs
}

func ValidateReplicationControllerStatus(status core.ReplicationControllerStatus, statusPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateNonnegativeField(int64(status.Replicas), statusPath.Child("replicas"))...)
        allErrs = append(allErrs, ValidateNonnegativeField(int64(status.FullyLabeledReplicas), statusPath.Child("fullyLabeledReplicas"))...)
        allErrs = append(allErrs, ValidateNonnegativeField(int64(status.ReadyReplicas), statusPath.Child("readyReplicas"))...)
        allErrs = append(allErrs, ValidateNonnegativeField(int64(status.AvailableReplicas), statusPath.Child("availableReplicas"))...)
        allErrs = append(allErrs, ValidateNonnegativeField(int64(status.ObservedGeneration), statusPath.Child("observedGeneration"))...)
        msg := "cannot be greater than status.replicas"
        if status.FullyLabeledReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(statusPath.Child("fullyLabeledReplicas"), status.FullyLabeledReplicas, msg))
        }
        if status.ReadyReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(statusPath.Child("readyReplicas"), status.ReadyReplicas, msg))
        }
        if status.AvailableReplicas > status.Replicas {
                allErrs = append(allErrs, field.Invalid(statusPath.Child("availableReplicas"), status.AvailableReplicas, msg))
        }
        if status.AvailableReplicas > status.ReadyReplicas {
                allErrs = append(allErrs, field.Invalid(statusPath.Child("availableReplicas"), status.AvailableReplicas, "cannot be greater than readyReplicas"))
        }
        return allErrs
}

// Validates that the given selector is non-empty.
func ValidateNonEmptySelector(selectorMap map[string]string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        selector := labels.Set(selectorMap).AsSelector()
        if selector.Empty() {
                allErrs = append(allErrs, field.Required(fldPath, ""))
        }
        return allErrs
}

// Validates the given template and ensures that it is in accordance with the desired selector and replicas.
func ValidatePodTemplateSpecForRC(template *core.PodTemplateSpec, selectorMap map[string]string, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if template == nil {
                allErrs = append(allErrs, field.Required(fldPath, ""))
        } else {
                selector := labels.Set(selectorMap).AsSelector()
                if !selector.Empty() {
                        // Verify that the RC selector matches the labels in template.
                        labels := labels.Set(template.Labels)
                        if !selector.Matches(labels) {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("metadata", "labels"), template.Labels, "`selector` does not match template `labels`"))
                        }
                }
                allErrs = append(allErrs, ValidatePodTemplateSpec(template, fldPath, opts)...)
                // RestartPolicy has already been first-order validated as per ValidatePodTemplateSpec().
                if template.Spec.RestartPolicy != core.RestartPolicyAlways {
                        allErrs = append(allErrs, field.NotSupported(fldPath.Child("spec", "restartPolicy"), template.Spec.RestartPolicy, []core.RestartPolicy{core.RestartPolicyAlways}))
                }
                if template.Spec.ActiveDeadlineSeconds != nil {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("spec", "activeDeadlineSeconds"), "activeDeadlineSeconds in ReplicationController is not Supported"))
                }
        }
        return allErrs
}

// ValidateReplicationControllerSpec tests if required fields in the replication controller spec are set.
func ValidateReplicationControllerSpec(spec, oldSpec *core.ReplicationControllerSpec, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateNonnegativeField(int64(spec.MinReadySeconds), fldPath.Child("minReadySeconds")).MarkCoveredByDeclarative()...)
        allErrs = append(allErrs, ValidateNonEmptySelector(spec.Selector, fldPath.Child("selector"))...)
        if spec.Replicas == nil {
                allErrs = append(allErrs, field.Required(fldPath.Child("replicas"), "").MarkCoveredByDeclarative())
        } else {
                allErrs = append(allErrs, ValidateNonnegativeField(int64(*spec.Replicas), fldPath.Child("replicas")).MarkCoveredByDeclarative()...)
        }
        allErrs = append(allErrs, ValidatePodTemplateSpecForRC(spec.Template, spec.Selector, fldPath.Child("template"), opts)...)
        return allErrs
}

// ValidatePodTemplateSpec validates the spec of a pod template
func ValidatePodTemplateSpec(spec *core.PodTemplateSpec, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, unversionedvalidation.ValidateLabels(spec.Labels, fldPath.Child("labels"))...)
        allErrs = append(allErrs, ValidateAnnotations(spec.Annotations, fldPath.Child("annotations"))...)
        allErrs = append(allErrs, ValidatePodSpecificAnnotations(spec.Annotations, &spec.Spec, fldPath.Child("annotations"), opts)...)
        allErrs = append(allErrs, ValidatePodSpec(&spec.Spec, nil, fldPath.Child("spec"), opts)...)
        allErrs = append(allErrs, validateSeccompAnnotationsAndFields(spec.ObjectMeta, &spec.Spec, fldPath.Child("spec"))...)
        allErrs = append(allErrs, validateAppArmorAnnotationsAndFieldsMatchOnCreate(spec.ObjectMeta, &spec.Spec, fldPath.Child("spec"))...)

        if len(spec.Spec.EphemeralContainers) > 0 {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("spec", "ephemeralContainers"), "ephemeral containers not allowed in pod template"))
        }

        return allErrs
}

// ValidateTaintsInNodeAnnotations tests that the serialized taints in Node.Annotations has valid data
func ValidateTaintsInNodeAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        taints, err := helper.GetTaintsFromNodeAnnotations(annotations)
        if err != nil {
                allErrs = append(allErrs, field.Invalid(fldPath, core.TaintsAnnotationKey, err.Error()))
                return allErrs
        }

        if len(taints) > 0 {
                allErrs = append(allErrs, validateNodeTaints(taints, fldPath.Child(core.TaintsAnnotationKey))...)
        }

        return allErrs
}

// validateNodeTaints tests if given taints have valid data.
func validateNodeTaints(taints []core.Taint, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}

        uniqueTaints := map[core.TaintEffect]sets.Set[string]{}

        for i, currTaint := range taints {
                idxPath := fldPath.Index(i)
                // validate the taint key
                allErrors = append(allErrors, unversionedvalidation.ValidateLabelName(currTaint.Key, idxPath.Child("key"))...)
                // validate the taint value
                if errs := validation.IsValidLabelValue(currTaint.Value); len(errs) != 0 {
                        allErrors = append(allErrors, field.Invalid(idxPath.Child("value"), currTaint.Value, strings.Join(errs, ";")))
                }
                // validate the taint effect
                allErrors = append(allErrors, validateTaintEffect(&currTaint.Effect, false, idxPath.Child("effect"))...)

                // validate if taint is unique by <key, effect>
                if len(uniqueTaints[currTaint.Effect]) > 0 && uniqueTaints[currTaint.Effect].Has(currTaint.Key) {
                        duplicatedError := field.Duplicate(idxPath, currTaint)
                        duplicatedError.Detail = "taints must be unique by key and effect pair"
                        allErrors = append(allErrors, duplicatedError)
                        continue
                }

                // add taint to existingTaints for uniqueness check
                if len(uniqueTaints[currTaint.Effect]) == 0 {
                        uniqueTaints[currTaint.Effect] = sets.Set[string]{}
                }
                uniqueTaints[currTaint.Effect].Insert(currTaint.Key)
        }
        return allErrors
}

func ValidateNodeSpecificAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if annotations[core.TaintsAnnotationKey] != "" {
                allErrs = append(allErrs, ValidateTaintsInNodeAnnotations(annotations, fldPath)...)
        }

        if annotations[core.PreferAvoidPodsAnnotationKey] != "" {
                allErrs = append(allErrs, ValidateAvoidPodsInNodeAnnotations(annotations, fldPath)...)
        }
        return allErrs
}

// ValidateNode tests if required fields in the node are set.
func ValidateNode(node *core.Node) field.ErrorList {
        fldPath := field.NewPath("metadata")
        allErrs := ValidateObjectMeta(&node.ObjectMeta, false, ValidateNodeName, fldPath)
        allErrs = append(allErrs, ValidateNodeSpecificAnnotations(node.ObjectMeta.Annotations, fldPath.Child("annotations"))...)
        if len(node.Spec.Taints) > 0 {
                allErrs = append(allErrs, validateNodeTaints(node.Spec.Taints, fldPath.Child("taints"))...)
        }

        // Only validate spec.
        // All status fields are optional and can be updated later.
        // That said, if specified, we need to ensure they are valid.
        allErrs = append(allErrs, ValidateNodeResources(node)...)
        allErrs = append(allErrs, validateNodeSwapStatus(node.Status.NodeInfo.Swap, fldPath.Child("nodeSwapStatus"))...)

        // validate PodCIDRS only if we need to
        if len(node.Spec.PodCIDRs) > 0 {
                podCIDRsField := field.NewPath("spec", "podCIDRs")

                // all PodCIDRs should be valid ones
                for idx, value := range node.Spec.PodCIDRs {
                        allErrs = append(allErrs, IsValidCIDRForLegacyField(podCIDRsField.Index(idx), value, nil)...)
                }

                // if more than PodCIDR then it must be a dual-stack pair
                if len(node.Spec.PodCIDRs) > 1 {
                        dualStack, err := netutils.IsDualStackCIDRStrings(node.Spec.PodCIDRs)
                        if err != nil {
                                allErrs = append(allErrs, field.InternalError(podCIDRsField, fmt.Errorf("invalid PodCIDRs. failed to check with dual stack with error:%v", err)))
                        }
                        if !dualStack || len(node.Spec.PodCIDRs) > 2 {
                                allErrs = append(allErrs, field.Invalid(podCIDRsField, node.Spec.PodCIDRs, "may specify no more than one CIDR for each IP family"))
                        }
                }
        }

        return allErrs
}

// ValidateNodeResources is used to make sure a node has valid capacity and allocatable values.
func ValidateNodeResources(node *core.Node) field.ErrorList {
        allErrs := field.ErrorList{}

        // Validate resource quantities in capacity.
        for k, v := range node.Status.Capacity {
                resPath := field.NewPath("status", "capacity", string(k))
                allErrs = append(allErrs, ValidateResourceQuantityValue(k, v, resPath)...)
        }

        // Validate resource quantities in allocatable.
        for k, v := range node.Status.Allocatable {
                resPath := field.NewPath("status", "allocatable", string(k))
                allErrs = append(allErrs, ValidateResourceQuantityValue(k, v, resPath)...)
        }
        return allErrs
}

// ValidateNodeUpdate tests to make sure a node update can be applied.  Modifies oldNode.
func ValidateNodeUpdate(node, oldNode *core.Node) field.ErrorList {
        fldPath := field.NewPath("metadata")
        allErrs := ValidateObjectMetaUpdate(&node.ObjectMeta, &oldNode.ObjectMeta, fldPath)
        allErrs = append(allErrs, ValidateNodeSpecificAnnotations(node.ObjectMeta.Annotations, fldPath.Child("annotations"))...)

        // TODO: Enable the code once we have better core object.status update model. Currently,
        // anyone can update node status.
        // if !apiequality.Semantic.DeepEqual(node.Status, core.NodeStatus{}) {
        //         allErrs = append(allErrs, field.Invalid("status", node.Status, "must be empty"))
        // }

        allErrs = append(allErrs, ValidateNodeResources(node)...)

        // Validate no duplicate addresses in node status.
        addresses := make(map[core.NodeAddress]bool)
        for i, address := range node.Status.Addresses {
                if _, ok := addresses[address]; ok {
                        allErrs = append(allErrs, field.Duplicate(field.NewPath("status", "addresses").Index(i), address))
                }
                addresses[address] = true
        }

        // Allow the controller manager to assign a CIDR to a node if it doesn't have one.
        if len(oldNode.Spec.PodCIDRs) > 0 {
                // compare the entire slice
                if len(oldNode.Spec.PodCIDRs) != len(node.Spec.PodCIDRs) {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "podCIDRs"), "node updates may not change podCIDR except from \"\" to valid"))
                } else {
                        for idx, value := range oldNode.Spec.PodCIDRs {
                                if value != node.Spec.PodCIDRs[idx] {
                                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "podCIDRs"), "node updates may not change podCIDR except from \"\" to valid"))
                                }
                        }
                }
        }

        // Allow controller manager updating provider ID when not set
        if len(oldNode.Spec.ProviderID) > 0 && oldNode.Spec.ProviderID != node.Spec.ProviderID {
                allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "providerID"), "node updates may not change providerID except from \"\" to valid"))
        }

        if node.Spec.ConfigSource != nil {
                allErrs = append(allErrs, validateNodeConfigSourceSpec(node.Spec.ConfigSource, field.NewPath("spec", "configSource"))...)
        }
        if node.Status.Config != nil {
                allErrs = append(allErrs, validateNodeConfigStatus(node.Status.Config, field.NewPath("status", "config"))...)
        }

        // update taints
        if len(node.Spec.Taints) > 0 {
                allErrs = append(allErrs, validateNodeTaints(node.Spec.Taints, fldPath.Child("taints"))...)
        }

        if node.Spec.DoNotUseExternalID != oldNode.Spec.DoNotUseExternalID {
                allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "externalID"), "may not be updated"))
        }

        // status and metadata are allowed change (barring restrictions above), so separately test spec field.
        // spec only has a few fields, so check the ones we don't allow changing
        //  1. PodCIDRs - immutable after first set - checked above
        //  2. ProviderID - immutable after first set - checked above
        //  3. Unschedulable - allowed to change
        //  4. Taints - allowed to change
        //  5. ConfigSource - allowed to change (and checked above)
        //  6. DoNotUseExternalID - immutable - checked above

        return allErrs
}

// validation specific to Node.Spec.ConfigSource
// The field ConfigSource is deprecated and will not be used. The validation is kept in place
// for the backward compatibility
func validateNodeConfigSourceSpec(source *core.NodeConfigSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        count := int(0)
        if source.ConfigMap != nil {
                count++
                allErrs = append(allErrs, validateConfigMapNodeConfigSourceSpec(source.ConfigMap, fldPath.Child("configMap"))...)
        }
        // add more subfields here in the future as they are added to NodeConfigSource

        // exactly one reference subfield must be non-nil
        if count != 1 {
                allErrs = append(allErrs, field.Invalid(fldPath, source, "exactly one reference subfield must be non-nil"))
        }
        return allErrs
}

// validation specific to Node.Spec.ConfigSource.ConfigMap
// The field ConfigSource is deprecated and will not be used. The validation is kept in place
// for the backward compatibility
func validateConfigMapNodeConfigSourceSpec(source *core.ConfigMapNodeConfigSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        // uid and resourceVersion must not be set in spec
        if string(source.UID) != "" {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("uid"), "uid must not be set in spec"))
        }
        if source.ResourceVersion != "" {
                allErrs = append(allErrs, field.Forbidden(fldPath.Child("resourceVersion"), "resourceVersion must not be set in spec"))
        }
        return append(allErrs, validateConfigMapNodeConfigSource(source, fldPath)...)
}

// validation specififc to Node.Status.Config
func validateNodeConfigStatus(status *core.NodeConfigStatus, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if status.Assigned != nil {
                allErrs = append(allErrs, validateNodeConfigSourceStatus(status.Assigned, fldPath.Child("assigned"))...)
        }
        if status.Active != nil {
                allErrs = append(allErrs, validateNodeConfigSourceStatus(status.Active, fldPath.Child("active"))...)
        }
        if status.LastKnownGood != nil {
                allErrs = append(allErrs, validateNodeConfigSourceStatus(status.LastKnownGood, fldPath.Child("lastKnownGood"))...)
        }
        return allErrs
}

// validation specific to Node.Status.Config.(Active|Assigned|LastKnownGood)
func validateNodeConfigSourceStatus(source *core.NodeConfigSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        count := int(0)
        if source.ConfigMap != nil {
                count++
                allErrs = append(allErrs, validateConfigMapNodeConfigSourceStatus(source.ConfigMap, fldPath.Child("configMap"))...)
        }
        // add more subfields here in the future as they are added to NodeConfigSource

        // exactly one reference subfield must be non-nil
        if count != 1 {
                allErrs = append(allErrs, field.Invalid(fldPath, source, "exactly one reference subfield must be non-nil"))
        }
        return allErrs
}

// validation specific to Node.Status.Config.(Active|Assigned|LastKnownGood).ConfigMap
func validateConfigMapNodeConfigSourceStatus(source *core.ConfigMapNodeConfigSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        // uid and resourceVersion must be set in status
        if string(source.UID) == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("uid"), ""))
        }
        if source.ResourceVersion == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("resourceVersion"), ""))
        }
        return append(allErrs, validateConfigMapNodeConfigSource(source, fldPath)...)
}

// common validation
func validateConfigMapNodeConfigSource(source *core.ConfigMapNodeConfigSource, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        // validate target configmap namespace
        if source.Namespace == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("namespace"), ""))
        } else {
                for _, msg := range ValidateNameFunc(ValidateNamespaceName)(source.Namespace, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("namespace"), source.Namespace, msg))
                }
        }
        // validate target configmap name
        if source.Name == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        } else {
                for _, msg := range ValidateNameFunc(ValidateConfigMapName)(source.Name, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("name"), source.Name, msg))
                }
        }
        // validate kubeletConfigKey against rules for configMap key names
        if source.KubeletConfigKey == "" {
                allErrs = append(allErrs, field.Required(fldPath.Child("kubeletConfigKey"), ""))
        } else {
                for _, msg := range validation.IsConfigMapKey(source.KubeletConfigKey) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("kubeletConfigKey"), source.KubeletConfigKey, msg))
                }
        }
        return allErrs
}

// Validate compute resource typename.
// Refer to docs/design/resources.md for more details.
func validateResourceName(value core.ResourceName, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, msg := range validation.IsQualifiedName(string(value)) {
                allErrs = append(allErrs, field.Invalid(fldPath, value, msg))
        }
        if len(allErrs) != 0 {
                return allErrs
        }

        if len(strings.Split(string(value), "/")) == 1 {
                if !helper.IsStandardResourceName(value) {
                        return append(allErrs, field.Invalid(fldPath, value, "must be a standard resource type or fully qualified"))
                }
        }

        return allErrs
}

// Validate container resource name
// Refer to docs/design/resources.md for more details.
func validateContainerResourceName(value core.ResourceName, fldPath *field.Path) field.ErrorList {
        allErrs := validateResourceName(value, fldPath)

        if len(strings.Split(string(value), "/")) == 1 {
                if !helper.IsStandardContainerResourceName(value) {
                        return append(allErrs, field.Invalid(fldPath, value, "must be a standard resource for containers"))
                }
        } else if !helper.IsNativeResource(value) {
                if !helper.IsExtendedResourceName(value) {
                        return append(allErrs, field.Invalid(fldPath, value, "doesn't follow extended resource name standard"))
                }
        }
        return allErrs
}

// validatePodResourceName verifies that:
// 1. The resource name is a valid compute resource name for pod-level specification.
// 2. The resource is supported by the PodLevelResources feature.
func validatePodResourceName(resourceName core.ResourceName, fldPath *field.Path) field.ErrorList {
        allErrs := validateResourceName(resourceName, fldPath)
        if len(allErrs) != 0 {
                return allErrs
        }

        if !resourcehelper.IsSupportedPodLevelResource(v1.ResourceName(resourceName)) {
                return append(allErrs, field.NotSupported(fldPath, resourceName, sets.List(resourcehelper.SupportedPodLevelResources())))
        }

        return allErrs
}

// Validate resource names that can go in a resource quota
// Refer to docs/design/resources.md for more details.
func ValidateResourceQuotaResourceName(value core.ResourceName, fldPath *field.Path) field.ErrorList {
        allErrs := validateResourceName(value, fldPath)

        if len(strings.Split(string(value), "/")) == 1 {
                if !helper.IsStandardQuotaResourceName(value) {
                        return append(allErrs, field.Invalid(fldPath, value, isInvalidQuotaResource))
                }
        }
        return allErrs
}

// Validate limit range types
func validateLimitRangeTypeName(value core.LimitType, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for _, msg := range validation.IsQualifiedName(string(value)) {
                allErrs = append(allErrs, field.Invalid(fldPath, value, msg))
        }
        if len(allErrs) != 0 {
                return allErrs
        }

        if len(strings.Split(string(value), "/")) == 1 {
                if !helper.IsStandardLimitRangeType(value) {
                        return append(allErrs, field.Invalid(fldPath, value, "must be a standard limit type or fully qualified"))
                }
        }

        return allErrs
}

// Validate limit range resource name
// limit types (other than Pod/Container) could contain storage not just cpu or memory
func validateLimitRangeResourceName(limitType core.LimitType, value core.ResourceName, fldPath *field.Path) field.ErrorList {
        switch limitType {
        case core.LimitTypePod, core.LimitTypeContainer:
                return validateContainerResourceName(value, fldPath)
        default:
                return validateResourceName(value, fldPath)
        }
}

// ValidateLimitRange tests if required fields in the LimitRange are set.
func ValidateLimitRange(limitRange *core.LimitRange) field.ErrorList {
        allErrs := ValidateObjectMeta(&limitRange.ObjectMeta, true, ValidateLimitRangeName, field.NewPath("metadata"))

        // ensure resource names are properly qualified per docs/design/resources.md
        limitTypeSet := map[core.LimitType]bool{}
        fldPath := field.NewPath("spec", "limits")
        for i := range limitRange.Spec.Limits {
                idxPath := fldPath.Index(i)
                limit := &limitRange.Spec.Limits[i]
                allErrs = append(allErrs, validateLimitRangeTypeName(limit.Type, idxPath.Child("type"))...)

                _, found := limitTypeSet[limit.Type]
                if found {
                        allErrs = append(allErrs, field.Duplicate(idxPath.Child("type"), limit.Type))
                }
                limitTypeSet[limit.Type] = true

                keys := sets.Set[string]{}
                min := map[string]resource.Quantity{}
                max := map[string]resource.Quantity{}
                defaults := map[string]resource.Quantity{}
                defaultRequests := map[string]resource.Quantity{}
                maxLimitRequestRatios := map[string]resource.Quantity{}

                for k, q := range limit.Max {
                        allErrs = append(allErrs, validateLimitRangeResourceName(limit.Type, k, idxPath.Child("max").Key(string(k)))...)
                        keys.Insert(string(k))
                        max[string(k)] = q
                }
                for k, q := range limit.Min {
                        allErrs = append(allErrs, validateLimitRangeResourceName(limit.Type, k, idxPath.Child("min").Key(string(k)))...)
                        keys.Insert(string(k))
                        min[string(k)] = q
                }

                if limit.Type == core.LimitTypePod {
                        if len(limit.Default) > 0 {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("default"), "may not be specified when `type` is 'Pod'"))
                        }
                        if len(limit.DefaultRequest) > 0 {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("defaultRequest"), "may not be specified when `type` is 'Pod'"))
                        }
                } else {
                        for k, q := range limit.Default {
                                allErrs = append(allErrs, validateLimitRangeResourceName(limit.Type, k, idxPath.Child("default").Key(string(k)))...)
                                keys.Insert(string(k))
                                defaults[string(k)] = q
                        }
                        for k, q := range limit.DefaultRequest {
                                allErrs = append(allErrs, validateLimitRangeResourceName(limit.Type, k, idxPath.Child("defaultRequest").Key(string(k)))...)
                                keys.Insert(string(k))
                                defaultRequests[string(k)] = q
                        }
                }

                if limit.Type == core.LimitTypePersistentVolumeClaim {
                        _, minQuantityFound := limit.Min[core.ResourceStorage]
                        _, maxQuantityFound := limit.Max[core.ResourceStorage]
                        if !minQuantityFound && !maxQuantityFound {
                                allErrs = append(allErrs, field.Required(idxPath.Child("limits"), "either minimum or maximum storage value is required, but neither was provided"))
                        }
                }

                for k, q := range limit.MaxLimitRequestRatio {
                        allErrs = append(allErrs, validateLimitRangeResourceName(limit.Type, k, idxPath.Child("maxLimitRequestRatio").Key(string(k)))...)
                        keys.Insert(string(k))
                        maxLimitRequestRatios[string(k)] = q
                }

                for k := range keys {
                        minQuantity, minQuantityFound := min[k]
                        maxQuantity, maxQuantityFound := max[k]
                        defaultQuantity, defaultQuantityFound := defaults[k]
                        defaultRequestQuantity, defaultRequestQuantityFound := defaultRequests[k]
                        maxRatio, maxRatioFound := maxLimitRequestRatios[k]

                        if minQuantityFound && maxQuantityFound && minQuantity.Cmp(maxQuantity) > 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("min").Key(string(k)), minQuantity, fmt.Sprintf("min value %s is greater than max value %s", minQuantity.String(), maxQuantity.String())))
                        }

                        if defaultRequestQuantityFound && minQuantityFound && minQuantity.Cmp(defaultRequestQuantity) > 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("defaultRequest").Key(string(k)), defaultRequestQuantity, fmt.Sprintf("min value %s is greater than default request value %s", minQuantity.String(), defaultRequestQuantity.String())))
                        }

                        if defaultRequestQuantityFound && maxQuantityFound && defaultRequestQuantity.Cmp(maxQuantity) > 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("defaultRequest").Key(string(k)), defaultRequestQuantity, fmt.Sprintf("default request value %s is greater than max value %s", defaultRequestQuantity.String(), maxQuantity.String())))
                        }

                        if defaultRequestQuantityFound && defaultQuantityFound && defaultRequestQuantity.Cmp(defaultQuantity) > 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("defaultRequest").Key(string(k)), defaultRequestQuantity, fmt.Sprintf("default request value %s is greater than default limit value %s", defaultRequestQuantity.String(), defaultQuantity.String())))
                        }

                        if defaultQuantityFound && minQuantityFound && minQuantity.Cmp(defaultQuantity) > 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("default").Key(string(k)), minQuantity, fmt.Sprintf("min value %s is greater than default value %s", minQuantity.String(), defaultQuantity.String())))
                        }

                        if defaultQuantityFound && maxQuantityFound && defaultQuantity.Cmp(maxQuantity) > 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("default").Key(string(k)), maxQuantity, fmt.Sprintf("default value %s is greater than max value %s", defaultQuantity.String(), maxQuantity.String())))
                        }
                        if maxRatioFound && maxRatio.Cmp(*resource.NewQuantity(1, resource.DecimalSI)) < 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("maxLimitRequestRatio").Key(string(k)), maxRatio, fmt.Sprintf("ratio %s is less than 1", maxRatio.String())))
                        }
                        if maxRatioFound && minQuantityFound && maxQuantityFound {
                                maxRatioValue := float64(maxRatio.Value())
                                minQuantityValue := minQuantity.Value()
                                maxQuantityValue := maxQuantity.Value()
                                if maxRatio.Value() < resource.MaxMilliValue && minQuantityValue < resource.MaxMilliValue && maxQuantityValue < resource.MaxMilliValue {
                                        maxRatioValue = float64(maxRatio.MilliValue()) / 1000
                                        minQuantityValue = minQuantity.MilliValue()
                                        maxQuantityValue = maxQuantity.MilliValue()
                                }
                                maxRatioLimit := float64(maxQuantityValue) / float64(minQuantityValue)
                                if maxRatioValue > maxRatioLimit {
                                        allErrs = append(allErrs, field.Invalid(idxPath.Child("maxLimitRequestRatio").Key(string(k)), maxRatio, fmt.Sprintf("ratio %s is greater than max/min = %f", maxRatio.String(), maxRatioLimit)))
                                }
                        }

                        // for GPU, hugepages and other resources that are not allowed to overcommit,
                        // the default value and defaultRequest value must match if both are specified
                        if !helper.IsOvercommitAllowed(core.ResourceName(k)) && defaultQuantityFound && defaultRequestQuantityFound && defaultQuantity.Cmp(defaultRequestQuantity) != 0 {
                                allErrs = append(allErrs, field.Invalid(idxPath.Child("defaultRequest").Key(string(k)), defaultRequestQuantity, fmt.Sprintf("default value %s must equal to defaultRequest value %s in %s", defaultQuantity.String(), defaultRequestQuantity.String(), k)))
                        }
                }
        }

        return allErrs
}

// ValidateServiceAccount tests if required fields in the ServiceAccount are set.
func ValidateServiceAccount(serviceAccount *core.ServiceAccount) field.ErrorList {
        allErrs := ValidateObjectMeta(&serviceAccount.ObjectMeta, true, ValidateServiceAccountName, field.NewPath("metadata"))
        return allErrs
}

// ValidateServiceAccountUpdate tests if required fields in the ServiceAccount are set.
func ValidateServiceAccountUpdate(newServiceAccount, oldServiceAccount *core.ServiceAccount) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newServiceAccount.ObjectMeta, &oldServiceAccount.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateServiceAccount(newServiceAccount)...)
        return allErrs
}

// ValidateSecret tests if required fields in the Secret are set.
func ValidateSecret(secret *core.Secret) field.ErrorList {
        allErrs := ValidateObjectMeta(&secret.ObjectMeta, true, ValidateSecretName, field.NewPath("metadata"))

        dataPath := field.NewPath("data")
        totalSize := 0
        for key, value := range secret.Data {
                for _, msg := range validation.IsConfigMapKey(key) {
                        allErrs = append(allErrs, field.Invalid(dataPath.Key(key), key, msg))
                }
                totalSize += len(value)
        }
        if totalSize > core.MaxSecretSize {
                allErrs = append(allErrs, field.TooLong(dataPath, "" /*unused*/, core.MaxSecretSize))
        }

        switch secret.Type {
        case core.SecretTypeServiceAccountToken:
                // Only require Annotations[kubernetes.io/service-account.name]
                // Additional fields (like Annotations[kubernetes.io/service-account.uid] and Data[token]) might be contributed later by a controller loop
                if value := secret.Annotations[core.ServiceAccountNameKey]; len(value) == 0 {
                        allErrs = append(allErrs, field.Required(field.NewPath("metadata", "annotations").Key(core.ServiceAccountNameKey), ""))
                }
        case core.SecretTypeOpaque, "":
        // no-op
        case core.SecretTypeDockercfg:
                dockercfgBytes, exists := secret.Data[core.DockerConfigKey]
                if !exists {
                        allErrs = append(allErrs, field.Required(dataPath.Key(core.DockerConfigKey), ""))
                        break
                }

                // make sure that the content is well-formed json.
                if err := json.Unmarshal(dockercfgBytes, &map[string]interface{}{}); err != nil {
                        allErrs = append(allErrs, field.Invalid(dataPath.Key(core.DockerConfigKey), "<secret contents redacted>", err.Error()))
                }
        case core.SecretTypeDockerConfigJSON:
                dockerConfigJSONBytes, exists := secret.Data[core.DockerConfigJSONKey]
                if !exists {
                        allErrs = append(allErrs, field.Required(dataPath.Key(core.DockerConfigJSONKey), ""))
                        break
                }

                // make sure that the content is well-formed json.
                if err := json.Unmarshal(dockerConfigJSONBytes, &map[string]interface{}{}); err != nil {
                        allErrs = append(allErrs, field.Invalid(dataPath.Key(core.DockerConfigJSONKey), "<secret contents redacted>", err.Error()))
                }
        case core.SecretTypeBasicAuth:
                _, usernameFieldExists := secret.Data[core.BasicAuthUsernameKey]
                _, passwordFieldExists := secret.Data[core.BasicAuthPasswordKey]

                // username or password might be empty, but the field must be present
                if !usernameFieldExists && !passwordFieldExists {
                        allErrs = append(allErrs, field.Required(dataPath.Key(core.BasicAuthUsernameKey), ""))
                        allErrs = append(allErrs, field.Required(dataPath.Key(core.BasicAuthPasswordKey), ""))
                        break
                }
        case core.SecretTypeSSHAuth:
                if len(secret.Data[core.SSHAuthPrivateKey]) == 0 {
                        allErrs = append(allErrs, field.Required(dataPath.Key(core.SSHAuthPrivateKey), ""))
                        break
                }

        case core.SecretTypeTLS:
                if _, exists := secret.Data[core.TLSCertKey]; !exists {
                        allErrs = append(allErrs, field.Required(dataPath.Key(core.TLSCertKey), ""))
                }
                if _, exists := secret.Data[core.TLSPrivateKeyKey]; !exists {
                        allErrs = append(allErrs, field.Required(dataPath.Key(core.TLSPrivateKeyKey), ""))
                }
        default:
                // no-op
        }

        return allErrs
}

// ValidateSecretUpdate tests if required fields in the Secret are set.
func ValidateSecretUpdate(newSecret, oldSecret *core.Secret) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newSecret.ObjectMeta, &oldSecret.ObjectMeta, field.NewPath("metadata"))

        allErrs = append(allErrs, ValidateImmutableField(newSecret.Type, oldSecret.Type, field.NewPath("type"))...)
        if oldSecret.Immutable != nil && *oldSecret.Immutable {
                if newSecret.Immutable == nil || !*newSecret.Immutable {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("immutable"), "field is immutable when `immutable` is set"))
                }
                if !reflect.DeepEqual(newSecret.Data, oldSecret.Data) {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("data"), "field is immutable when `immutable` is set"))
                }
                // We don't validate StringData, as it was already converted back to Data
                // before validation is happening.
        }

        allErrs = append(allErrs, ValidateSecret(newSecret)...)
        return allErrs
}

// ValidateConfigMapName can be used to check whether the given ConfigMap name is valid.
// Prefix indicates this name will be used as part of generation, in which case
// trailing dashes are allowed.
var ValidateConfigMapName = apimachineryvalidation.NameIsDNSSubdomain

// ValidateConfigMap tests whether required fields in the ConfigMap are set.
func ValidateConfigMap(cfg *core.ConfigMap) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateObjectMeta(&cfg.ObjectMeta, true, ValidateConfigMapName, field.NewPath("metadata"))...)

        totalSize := 0

        for key, value := range cfg.Data {
                for _, msg := range validation.IsConfigMapKey(key) {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("data").Key(key), key, msg))
                }
                // check if we have a duplicate key in the other bag
                if _, isValue := cfg.BinaryData[key]; isValue {
                        msg := "duplicate of key present in binaryData"
                        allErrs = append(allErrs, field.Invalid(field.NewPath("data").Key(key), key, msg))
                }
                totalSize += len(value)
        }
        for key, value := range cfg.BinaryData {
                for _, msg := range validation.IsConfigMapKey(key) {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("binaryData").Key(key), key, msg))
                }
                totalSize += len(value)
        }
        if totalSize > core.MaxSecretSize {
                // pass back "" to indicate that the error refers to the whole object.
                allErrs = append(allErrs, field.TooLong(field.NewPath(""), "" /*unused*/, core.MaxSecretSize))
        }

        return allErrs
}

// ValidateConfigMapUpdate tests if required fields in the ConfigMap are set.
func ValidateConfigMapUpdate(newCfg, oldCfg *core.ConfigMap) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateObjectMetaUpdate(&newCfg.ObjectMeta, &oldCfg.ObjectMeta, field.NewPath("metadata"))...)

        if oldCfg.Immutable != nil && *oldCfg.Immutable {
                if newCfg.Immutable == nil || !*newCfg.Immutable {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("immutable"), "field is immutable when `immutable` is set"))
                }
                if !reflect.DeepEqual(newCfg.Data, oldCfg.Data) {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("data"), "field is immutable when `immutable` is set"))
                }
                if !reflect.DeepEqual(newCfg.BinaryData, oldCfg.BinaryData) {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("binaryData"), "field is immutable when `immutable` is set"))
                }
        }

        allErrs = append(allErrs, ValidateConfigMap(newCfg)...)
        return allErrs
}

func validateBasicResource(quantity resource.Quantity, fldPath *field.Path) field.ErrorList {
        if quantity.Value() < 0 {
                return field.ErrorList{field.Invalid(fldPath, quantity.Value(), "must be a valid resource quantity")}
        }
        return field.ErrorList{}
}

func validatePodResourceRequirements(requirements *core.ResourceRequirements, podClaimNames sets.Set[string], fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        return validateResourceRequirements(requirements, validatePodResourceName, podClaimNames, fldPath, opts)
}

func ValidateContainerResourceRequirements(requirements *core.ResourceRequirements, podClaimNames sets.Set[string], fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        return validateResourceRequirements(requirements, validateContainerResourceName, podClaimNames, fldPath, opts)
}

// Validates resource requirement spec.
func validateResourceRequirements(requirements *core.ResourceRequirements, resourceNameFn func(core.ResourceName, *field.Path) field.ErrorList, podClaimNames sets.Set[string], fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        limPath := fldPath.Child("limits")
        reqPath := fldPath.Child("requests")
        limContainsCPUOrMemory := false
        reqContainsCPUOrMemory := false
        limContainsHugePages := false
        reqContainsHugePages := false
        supportedQoSComputeResources := sets.New(core.ResourceCPU, core.ResourceMemory)
        for resourceName, quantity := range requirements.Limits {

                fldPath := limPath.Key(string(resourceName))
                // Validate resource name.
                allErrs = append(allErrs, resourceNameFn(resourceName, fldPath)...)

                // Validate resource quantity.
                allErrs = append(allErrs, ValidateResourceQuantityValue(resourceName, quantity, fldPath)...)

                if helper.IsHugePageResourceName(resourceName) {
                        limContainsHugePages = true
                        if err := validateResourceQuantityHugePageValue(resourceName, quantity, opts); err != nil {
                                allErrs = append(allErrs, field.Invalid(fldPath, quantity.String(), err.Error()))
                        }
                }

                if supportedQoSComputeResources.Has(resourceName) {
                        limContainsCPUOrMemory = true
                }
        }
        for resourceName, quantity := range requirements.Requests {
                fldPath := reqPath.Key(string(resourceName))
                // Validate resource name.
                allErrs = append(allErrs, resourceNameFn(resourceName, fldPath)...)

                // Validate resource quantity.
                allErrs = append(allErrs, ValidateResourceQuantityValue(resourceName, quantity, fldPath)...)

                // Check that request <= limit.
                limitQuantity, exists := requirements.Limits[resourceName]
                if exists {
                        // For non overcommitable resources, not only requests can't exceed limits, they also can't be lower, i.e. must be equal.
                        if quantity.Cmp(limitQuantity) != 0 && !helper.IsOvercommitAllowed(resourceName) {
                                allErrs = append(allErrs, field.Invalid(reqPath, quantity.String(), fmt.Sprintf("must be equal to %s limit of %s", resourceName, limitQuantity.String())))
                        } else if quantity.Cmp(limitQuantity) > 0 {
                                allErrs = append(allErrs, field.Invalid(reqPath, quantity.String(), fmt.Sprintf("must be less than or equal to %s limit of %s", resourceName, limitQuantity.String())))
                        }
                } else if !helper.IsOvercommitAllowed(resourceName) {
                        allErrs = append(allErrs, field.Required(limPath, "Limit must be set for non overcommitable resources"))
                }
                if helper.IsHugePageResourceName(resourceName) {
                        reqContainsHugePages = true
                        if err := validateResourceQuantityHugePageValue(resourceName, quantity, opts); err != nil {
                                allErrs = append(allErrs, field.Invalid(fldPath, quantity.String(), err.Error()))
                        }
                }
                if supportedQoSComputeResources.Has(resourceName) {
                        reqContainsCPUOrMemory = true
                }

        }
        if !limContainsCPUOrMemory && !reqContainsCPUOrMemory && (reqContainsHugePages || limContainsHugePages) {
                allErrs = append(allErrs, field.Forbidden(fldPath, "HugePages require cpu or memory"))
        }

        allErrs = append(allErrs, validateResourceClaimNames(requirements.Claims, podClaimNames, fldPath.Child("claims"))...)

        return allErrs
}

// validateResourceClaimNames checks that the names in
// ResourceRequirements.Claims have a corresponding entry in
// PodSpec.ResourceClaims.
func validateResourceClaimNames(claims []core.ResourceClaim, podClaimNames sets.Set[string], fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        names := sets.Set[string]{}
        for i, claim := range claims {
                name := claim.Name
                if name == "" {
                        allErrs = append(allErrs, field.Required(fldPath.Index(i), ""))
                } else {
                        if names.Has(name) {
                                // All requests of that claim already referenced.
                                allErrs = append(allErrs, field.Duplicate(fldPath.Index(i), name))
                        } else {
                                key := name
                                if claim.Request != "" {
                                        allErrs = append(allErrs, ValidateDNS1123Label(claim.Request, fldPath.Index(i).Child("request"))...)
                                        key += "/" + claim.Request
                                }
                                if names.Has(key) {
                                        // The exact same entry was already referenced.
                                        allErrs = append(allErrs, field.Duplicate(fldPath.Index(i), key))
                                } else if claim.Request == "" {
                                        // When referencing a claim, there's an
                                        // overlap when previously some request
                                        // in the claim was referenced. This
                                        // cannot be checked with a map lookup,
                                        // we need to iterate.
                                        for key := range names {
                                                index := strings.Index(key, "/")
                                                if index < 0 {
                                                        continue
                                                }
                                                if key[0:index] == name {
                                                        allErrs = append(allErrs, field.Duplicate(fldPath.Index(i), name))
                                                }
                                        }
                                }

                                names.Insert(key)
                        }
                        if !podClaimNames.Has(name) {
                                // field.NotFound doesn't accept an
                                // explanation. Adding one here is more
                                // user-friendly.
                                error := field.NotFound(fldPath.Index(i), name)
                                error.Detail = "must be one of the names in pod.spec.resourceClaims"
                                if len(podClaimNames) == 0 {
                                        error.Detail += " which is empty"
                                } else {
                                        error.Detail += ": " + strings.Join(sets.List(podClaimNames), ", ")
                                }
                                allErrs = append(allErrs, error)
                        }
                }
        }
        return allErrs
}

func validateResourceQuantityHugePageValue(name core.ResourceName, quantity resource.Quantity, opts PodValidationOptions) error {
        if !helper.IsHugePageResourceName(name) {
                return nil
        }

        if !opts.AllowIndivisibleHugePagesValues && !helper.IsHugePageResourceValueDivisible(name, quantity) {
                return fmt.Errorf("%s is not positive integer multiple of %s", quantity.String(), name)
        }

        return nil
}

// validateResourceQuotaScopes ensures that each enumerated hard resource constraint is valid for set of scopes
func validateResourceQuotaScopes(resourceQuotaSpec *core.ResourceQuotaSpec, fld *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(resourceQuotaSpec.Scopes) == 0 {
                return allErrs
        }
        hardLimits := sets.New[core.ResourceName]()
        for k := range resourceQuotaSpec.Hard {
                hardLimits.Insert(k)
        }
        fldPath := fld.Child("scopes")
        scopeSet := sets.New[core.ResourceQuotaScope]()
        for _, scope := range resourceQuotaSpec.Scopes {
                if !helper.IsStandardResourceQuotaScope(scope) {
                        allErrs = append(allErrs, field.Invalid(fldPath, resourceQuotaSpec.Scopes, "unsupported scope"))
                }
                for _, k := range sets.List(hardLimits) {
                        if helper.IsStandardQuotaResourceName(k) && !helper.IsResourceQuotaScopeValidForResource(scope, k) {
                                allErrs = append(allErrs, field.Invalid(fldPath, resourceQuotaSpec.Scopes, "unsupported scope applied to resource"))
                        }
                }
                scopeSet.Insert(scope)
        }
        invalidScopePairs := []sets.Set[core.ResourceQuotaScope]{
                sets.New(core.ResourceQuotaScopeBestEffort, core.ResourceQuotaScopeNotBestEffort),
                sets.New(core.ResourceQuotaScopeTerminating, core.ResourceQuotaScopeNotTerminating),
        }
        for _, invalidScopePair := range invalidScopePairs {
                if scopeSet.HasAll(sets.List(invalidScopePair)...) {
                        allErrs = append(allErrs, field.Invalid(fldPath, resourceQuotaSpec.Scopes, "conflicting scopes"))
                }
        }
        return allErrs
}

// validateScopedResourceSelectorRequirement tests that the match expressions has valid data
func validateScopedResourceSelectorRequirement(resourceQuotaSpec *core.ResourceQuotaSpec, fld *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        hardLimits := sets.New[core.ResourceName]()
        for k := range resourceQuotaSpec.Hard {
                hardLimits.Insert(k)
        }
        fldPath := fld.Child("matchExpressions")
        scopeSet := sets.New[core.ResourceQuotaScope]()
        for _, req := range resourceQuotaSpec.ScopeSelector.MatchExpressions {
                if !helper.IsStandardResourceQuotaScope(req.ScopeName) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("scopeName"), req.ScopeName, "unsupported scope"))
                }
                for _, k := range sets.List(hardLimits) {
                        if helper.IsStandardQuotaResourceName(k) && !helper.IsResourceQuotaScopeValidForResource(req.ScopeName, k) {
                                allErrs = append(allErrs, field.Invalid(fldPath, resourceQuotaSpec.ScopeSelector, "unsupported scope applied to resource"))
                        }
                }
                switch req.ScopeName {
                case core.ResourceQuotaScopeBestEffort, core.ResourceQuotaScopeNotBestEffort, core.ResourceQuotaScopeTerminating, core.ResourceQuotaScopeNotTerminating, core.ResourceQuotaScopeCrossNamespacePodAffinity:
                        if req.Operator != core.ScopeSelectorOpExists {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("operator"), req.Operator,
                                        "must be 'Exists' when scope is any of ResourceQuotaScopeTerminating, ResourceQuotaScopeNotTerminating, ResourceQuotaScopeBestEffort, ResourceQuotaScopeNotBestEffort or ResourceQuotaScopeCrossNamespacePodAffinity"))
                        }
                }

                switch req.Operator {
                case core.ScopeSelectorOpIn, core.ScopeSelectorOpNotIn:
                        if len(req.Values) == 0 {
                                allErrs = append(allErrs, field.Required(fldPath.Child("values"),
                                        "must be at least one value when `operator` is 'In' or 'NotIn' for scope selector"))
                        }
                case core.ScopeSelectorOpExists, core.ScopeSelectorOpDoesNotExist:
                        if len(req.Values) != 0 {
                                allErrs = append(allErrs, field.Invalid(fldPath.Child("values"), req.Values,
                                        "must be no value when `operator` is 'Exist' or 'DoesNotExist' for scope selector"))
                        }
                default:
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("operator"), req.Operator, "not a valid selector operator"))
                }
                scopeSet.Insert(req.ScopeName)
        }
        invalidScopePairs := []sets.Set[core.ResourceQuotaScope]{
                sets.New(core.ResourceQuotaScopeBestEffort, core.ResourceQuotaScopeNotBestEffort),
                sets.New(core.ResourceQuotaScopeTerminating, core.ResourceQuotaScopeNotTerminating),
        }
        for _, invalidScopePair := range invalidScopePairs {
                if scopeSet.HasAll(sets.List(invalidScopePair)...) {
                        allErrs = append(allErrs, field.Invalid(fldPath, resourceQuotaSpec.Scopes, "conflicting scopes"))
                }
        }

        return allErrs
}

// validateScopeSelector tests that the specified scope selector has valid data
func validateScopeSelector(resourceQuotaSpec *core.ResourceQuotaSpec, fld *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if resourceQuotaSpec.ScopeSelector == nil {
                return allErrs
        }
        allErrs = append(allErrs, validateScopedResourceSelectorRequirement(resourceQuotaSpec, fld.Child("scopeSelector"))...)
        return allErrs
}

// ValidateResourceQuota tests if required fields in the ResourceQuota are set.
func ValidateResourceQuota(resourceQuota *core.ResourceQuota) field.ErrorList {
        allErrs := ValidateObjectMeta(&resourceQuota.ObjectMeta, true, ValidateResourceQuotaName, field.NewPath("metadata"))

        allErrs = append(allErrs, ValidateResourceQuotaSpec(&resourceQuota.Spec, field.NewPath("spec"))...)
        allErrs = append(allErrs, ValidateResourceQuotaStatus(&resourceQuota.Status, field.NewPath("status"))...)

        return allErrs
}

func ValidateResourceQuotaStatus(status *core.ResourceQuotaStatus, fld *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        fldPath := fld.Child("hard")
        for k, v := range status.Hard {
                resPath := fldPath.Key(string(k))
                allErrs = append(allErrs, ValidateResourceQuotaResourceName(k, resPath)...)
                allErrs = append(allErrs, ValidateResourceQuantityValue(k, v, resPath)...)
        }
        fldPath = fld.Child("used")
        for k, v := range status.Used {
                resPath := fldPath.Key(string(k))
                allErrs = append(allErrs, ValidateResourceQuotaResourceName(k, resPath)...)
                allErrs = append(allErrs, ValidateResourceQuantityValue(k, v, resPath)...)
        }

        return allErrs
}

func ValidateResourceQuotaSpec(resourceQuotaSpec *core.ResourceQuotaSpec, fld *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        fldPath := fld.Child("hard")
        for k, v := range resourceQuotaSpec.Hard {
                resPath := fldPath.Key(string(k))
                allErrs = append(allErrs, ValidateResourceQuotaResourceName(k, resPath)...)
                allErrs = append(allErrs, ValidateResourceQuantityValue(k, v, resPath)...)
        }

        allErrs = append(allErrs, validateResourceQuotaScopes(resourceQuotaSpec, fld)...)
        allErrs = append(allErrs, validateScopeSelector(resourceQuotaSpec, fld)...)

        return allErrs
}

// ValidateResourceQuantityValue enforces that specified quantity is valid for specified resource
func ValidateResourceQuantityValue(resource core.ResourceName, value resource.Quantity, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, ValidateNonnegativeQuantity(value, fldPath)...)
        if helper.IsIntegerResourceName(resource) {
                if value.MilliValue()%int64(1000) != int64(0) {
                        allErrs = append(allErrs, field.Invalid(fldPath, value, isNotIntegerErrorMsg))
                }
        }
        return allErrs
}

// ValidateResourceQuotaUpdate tests to see if the update is legal for an end user to make.
func ValidateResourceQuotaUpdate(newResourceQuota, oldResourceQuota *core.ResourceQuota) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newResourceQuota.ObjectMeta, &oldResourceQuota.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateResourceQuotaSpec(&newResourceQuota.Spec, field.NewPath("spec"))...)

        // ensure scopes cannot change, and that resources are still valid for scope
        fldPath := field.NewPath("spec", "scopes")
        oldScopes := sets.New[string]()
        newScopes := sets.New[string]()
        for _, scope := range newResourceQuota.Spec.Scopes {
                newScopes.Insert(string(scope))
        }
        for _, scope := range oldResourceQuota.Spec.Scopes {
                oldScopes.Insert(string(scope))
        }
        if !oldScopes.Equal(newScopes) {
                allErrs = append(allErrs, field.Invalid(fldPath, newResourceQuota.Spec.Scopes, fieldImmutableErrorMsg))
        }

        return allErrs
}

// ValidateResourceQuotaStatusUpdate tests to see if the status update is legal for an end user to make.
func ValidateResourceQuotaStatusUpdate(newResourceQuota, oldResourceQuota *core.ResourceQuota) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newResourceQuota.ObjectMeta, &oldResourceQuota.ObjectMeta, field.NewPath("metadata"))
        if len(newResourceQuota.ResourceVersion) == 0 {
                allErrs = append(allErrs, field.Required(field.NewPath("resourceVersion"), ""))
        }
        fldPath := field.NewPath("status", "hard")
        for k, v := range newResourceQuota.Status.Hard {
                resPath := fldPath.Key(string(k))
                allErrs = append(allErrs, ValidateResourceQuotaResourceName(k, resPath)...)
                allErrs = append(allErrs, ValidateResourceQuantityValue(k, v, resPath)...)
        }
        fldPath = field.NewPath("status", "used")
        for k, v := range newResourceQuota.Status.Used {
                resPath := fldPath.Key(string(k))
                allErrs = append(allErrs, ValidateResourceQuotaResourceName(k, resPath)...)
                allErrs = append(allErrs, ValidateResourceQuantityValue(k, v, resPath)...)
        }
        return allErrs
}

// ValidateNamespace tests if required fields are set.
func ValidateNamespace(namespace *core.Namespace) field.ErrorList {
        allErrs := ValidateObjectMeta(&namespace.ObjectMeta, false, ValidateNamespaceName, field.NewPath("metadata"))
        for i := range namespace.Spec.Finalizers {
                allErrs = append(allErrs, validateFinalizerName(string(namespace.Spec.Finalizers[i]), field.NewPath("spec", "finalizers"))...)
        }
        return allErrs
}

// Validate finalizer names
func validateFinalizerName(stringValue string, fldPath *field.Path) field.ErrorList {
        allErrs := apimachineryvalidation.ValidateFinalizerName(stringValue, fldPath)
        allErrs = append(allErrs, validateKubeFinalizerName(stringValue, fldPath)...)
        return allErrs
}

// validateKubeFinalizerName checks for "standard" names of legacy finalizer
func validateKubeFinalizerName(stringValue string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if len(strings.Split(stringValue, "/")) == 1 {
                if !helper.IsStandardFinalizerName(stringValue) {
                        return append(allErrs, field.Invalid(fldPath, stringValue, "name is neither a standard finalizer name nor is it fully qualified"))
                }
        }

        return allErrs
}

// ValidateNamespaceUpdate tests to make sure a namespace update can be applied.
func ValidateNamespaceUpdate(newNamespace *core.Namespace, oldNamespace *core.Namespace) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newNamespace.ObjectMeta, &oldNamespace.ObjectMeta, field.NewPath("metadata"))
        return allErrs
}

// ValidateNamespaceStatusUpdate tests to see if the update is legal for an end user to make.
func ValidateNamespaceStatusUpdate(newNamespace, oldNamespace *core.Namespace) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newNamespace.ObjectMeta, &oldNamespace.ObjectMeta, field.NewPath("metadata"))
        if newNamespace.DeletionTimestamp.IsZero() {
                if newNamespace.Status.Phase != core.NamespaceActive {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("status", "Phase"), newNamespace.Status.Phase, "may only be 'Active' if `deletionTimestamp` is empty"))
                }
        } else {
                if newNamespace.Status.Phase != core.NamespaceTerminating {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("status", "Phase"), newNamespace.Status.Phase, "may only be 'Terminating' if `deletionTimestamp` is not empty"))
                }
        }
        return allErrs
}

// ValidateNamespaceFinalizeUpdate tests to see if the update is legal for an end user to make.
func ValidateNamespaceFinalizeUpdate(newNamespace, oldNamespace *core.Namespace) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newNamespace.ObjectMeta, &oldNamespace.ObjectMeta, field.NewPath("metadata"))

        fldPath := field.NewPath("spec", "finalizers")
        for i := range newNamespace.Spec.Finalizers {
                idxPath := fldPath.Index(i)
                allErrs = append(allErrs, validateFinalizerName(string(newNamespace.Spec.Finalizers[i]), idxPath)...)
        }
        return allErrs
}

// ValidateEndpoints validates Endpoints on create and update.
func ValidateEndpoints(endpoints, oldEndpoints *core.Endpoints) field.ErrorList {
        allErrs := ValidateObjectMeta(&endpoints.ObjectMeta, true, ValidateEndpointsName, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateEndpointsSpecificAnnotations(endpoints.Annotations, field.NewPath("annotations"))...)

        subsetErrs := validateEndpointSubsets(endpoints.Subsets, field.NewPath("subsets"))
        if len(subsetErrs) != 0 {
                // If this is an update, and Subsets was unchanged, then ignore the
                // validation errors, since apparently older versions of Kubernetes
                // considered the data valid. (We only check this after getting a
                // validation error since Endpoints may be large and DeepEqual is slow.)
                if oldEndpoints != nil && apiequality.Semantic.DeepEqual(oldEndpoints.Subsets, endpoints.Subsets) {
                        subsetErrs = nil
                }
        }
        allErrs = append(allErrs, subsetErrs...)

        return allErrs
}

// ValidateEndpointsCreate validates Endpoints on create.
func ValidateEndpointsCreate(endpoints *core.Endpoints) field.ErrorList {
        return ValidateEndpoints(endpoints, nil)
}

// ValidateEndpointsUpdate validates Endpoints on update. NodeName changes are
// allowed during update to accommodate the case where nodeIP or PodCIDR is
// reused. An existing endpoint ip will have a different nodeName if this
// happens.
func ValidateEndpointsUpdate(newEndpoints, oldEndpoints *core.Endpoints) field.ErrorList {
        allErrs := ValidateObjectMetaUpdate(&newEndpoints.ObjectMeta, &oldEndpoints.ObjectMeta, field.NewPath("metadata"))
        allErrs = append(allErrs, ValidateEndpoints(newEndpoints, oldEndpoints)...)
        return allErrs
}

func validateEndpointSubsets(subsets []core.EndpointSubset, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        for i := range subsets {
                ss := &subsets[i]
                idxPath := fldPath.Index(i)

                // EndpointSubsets must include endpoint address. For headless service, we allow its endpoints not to have ports.
                if len(ss.Addresses) == 0 && len(ss.NotReadyAddresses) == 0 {
                        // TODO: consider adding a RequiredOneOf() error for this and similar cases
                        allErrs = append(allErrs, field.Required(idxPath, "must specify `addresses` or `notReadyAddresses`"))
                }
                for addr := range ss.Addresses {
                        allErrs = append(allErrs, validateEndpointAddress(&ss.Addresses[addr], idxPath.Child("addresses").Index(addr))...)
                }
                for addr := range ss.NotReadyAddresses {
                        allErrs = append(allErrs, validateEndpointAddress(&ss.NotReadyAddresses[addr], idxPath.Child("notReadyAddresses").Index(addr))...)
                }
                for port := range ss.Ports {
                        allErrs = append(allErrs, validateEndpointPort(&ss.Ports[port], len(ss.Ports) > 1, idxPath.Child("ports").Index(port))...)
                }
        }

        return allErrs
}

func validateEndpointAddress(address *core.EndpointAddress, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        allErrs = append(allErrs, IsValidIPForLegacyField(fldPath.Child("ip"), address.IP, nil)...)
        if len(address.Hostname) > 0 {
                allErrs = append(allErrs, ValidateDNS1123Label(address.Hostname, fldPath.Child("hostname"))...)
        }
        // During endpoint update, verify that NodeName is a DNS subdomain and transition rules allow the update
        if address.NodeName != nil {
                for _, msg := range ValidateNodeName(*address.NodeName, false) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("nodeName"), *address.NodeName, msg).WithOrigin("format=dns-label"))
                }
        }
        allErrs = append(allErrs, ValidateEndpointIP(address.IP, fldPath.Child("ip"))...)
        return allErrs
}

// ValidateEndpointIP is used to validate Endpoints and EndpointSlice addresses, and also
// (for historical reasons) external IPs. It disallows certain address types that don't
// make sense in those contexts. Note that this function is _almost_, but not exactly,
// equivalent to net.IP.IsGlobalUnicast(). (Unlike IsGlobalUnicast, it allows global
// multicast IPs, which is probably a bug.)
//
// This function should not be used for new validations; the exact set of IPs that do and
// don't make sense in a particular field is context-dependent (e.g., localhost makes
// sense in some places; unspecified IPs make sense in fields that are used as bind
// addresses rather than destination addresses).
func ValidateEndpointIP(ipAddress string, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        ip := netutils.ParseIPSloppy(ipAddress)
        if ip == nil {
                allErrs = append(allErrs, field.Invalid(fldPath, ipAddress, "must be a valid IP address").WithOrigin("format=ip-sloppy"))
                return allErrs
        }
        if ip.IsUnspecified() {
                allErrs = append(allErrs, field.Invalid(fldPath, ipAddress, fmt.Sprintf("may not be unspecified (%v)", ipAddress)))
        }
        if ip.IsLoopback() {
                allErrs = append(allErrs, field.Invalid(fldPath, ipAddress, "may not be in the loopback range (127.0.0.0/8, ::1/128)"))
        }
        if ip.IsLinkLocalUnicast() {
                allErrs = append(allErrs, field.Invalid(fldPath, ipAddress, "may not be in the link-local range (169.254.0.0/16, fe80::/10)"))
        }
        if ip.IsLinkLocalMulticast() {
                allErrs = append(allErrs, field.Invalid(fldPath, ipAddress, "may not be in the link-local multicast range (224.0.0.0/24, ff02::/10)"))
        }
        return allErrs.WithOrigin("format=endpoint-ip")
}

func validateEndpointPort(port *core.EndpointPort, requireName bool, fldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}
        if requireName && len(port.Name) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("name"), ""))
        } else if len(port.Name) != 0 {
                allErrs = append(allErrs, ValidateDNS1123Label(port.Name, fldPath.Child("name"))...)
        }
        for _, msg := range validation.IsValidPortNum(int(port.Port)) {
                allErrs = append(allErrs, field.Invalid(fldPath.Child("port"), port.Port, msg).WithOrigin("portNum"))
        }
        if len(port.Protocol) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("protocol"), ""))
        } else if !supportedPortProtocols.Has(port.Protocol) {
                allErrs = append(allErrs, field.NotSupported(fldPath.Child("protocol"), port.Protocol, sets.List(supportedPortProtocols)))
        }
        if port.AppProtocol != nil {
                allErrs = append(allErrs, ValidateQualifiedName(*port.AppProtocol, fldPath.Child("appProtocol"))...)
        }
        return allErrs
}

// ValidateSecurityContext ensures the security context contains valid settings
func ValidateSecurityContext(sc *core.SecurityContext, fldPath *field.Path, hostUsers bool) field.ErrorList {
        allErrs := field.ErrorList{}
        // this should only be true for testing since SecurityContext is defaulted by the core
        if sc == nil {
                return allErrs
        }

        if sc.Privileged != nil {
                if *sc.Privileged && !capabilities.Get().AllowPrivileged {
                        allErrs = append(allErrs, field.Forbidden(fldPath.Child("privileged"), "disallowed by cluster policy"))
                }
        }

        if sc.RunAsUser != nil {
                for _, msg := range validation.IsValidUserID(*sc.RunAsUser) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("runAsUser"), *sc.RunAsUser, msg))
                }
        }

        if sc.RunAsGroup != nil {
                for _, msg := range validation.IsValidGroupID(*sc.RunAsGroup) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("runAsGroup"), *sc.RunAsGroup, msg))
                }
        }

        if sc.ProcMount != nil {
                if err := ValidateProcMountType(fldPath.Child("procMount"), *sc.ProcMount); err != nil {
                        allErrs = append(allErrs, err)
                }
                if hostUsers && *sc.ProcMount == core.UnmaskedProcMount {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("procMount"), sc.ProcMount, "`hostUsers` must be false to use `Unmasked`"))
                }

        }
        allErrs = append(allErrs, validateSeccompProfileField(sc.SeccompProfile, fldPath.Child("seccompProfile"))...)
        if sc.AllowPrivilegeEscalation != nil && !*sc.AllowPrivilegeEscalation {
                if sc.Privileged != nil && *sc.Privileged {
                        allErrs = append(allErrs, field.Invalid(fldPath, sc, "cannot set `allowPrivilegeEscalation` to false and `privileged` to true"))
                }

                if sc.Capabilities != nil {
                        for _, cap := range sc.Capabilities.Add {
                                if string(cap) == "CAP_SYS_ADMIN" {
                                        allErrs = append(allErrs, field.Invalid(fldPath, sc, "cannot set `allowPrivilegeEscalation` to false and `capabilities.Add` CAP_SYS_ADMIN"))
                                }
                        }
                }
        }

        allErrs = append(allErrs, validateWindowsSecurityContextOptions(sc.WindowsOptions, fldPath.Child("windowsOptions"))...)
        allErrs = append(allErrs, ValidateAppArmorProfileField(sc.AppArmorProfile, fldPath.Child("appArmorProfile"))...)

        return allErrs
}

// maxGMSACredentialSpecLength is the max length, in bytes, for the actual contents
// of a GMSA cred spec. In general, those shouldn't be more than a few hundred bytes,
// so we want to give plenty of room here while still providing an upper bound.
// The runAsUserName field will be used to execute the given container's entrypoint, and
// it can be formatted as "DOMAIN/USER", where the DOMAIN is optional, maxRunAsUserNameDomainLength
// is the max character length for the user's DOMAIN, and maxRunAsUserNameUserLength
// is the max character length for the USER itself. Both the DOMAIN and USER have their
// own restrictions, and more information about them can be found here:
// https://support.microsoft.com/en-us/help/909264/naming-conventions-in-active-directory-for-computers-domains-sites-and
// https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-2000-server/bb726984(v=technet.10)
const (
        maxGMSACredentialSpecLengthInKiB = 64
        maxGMSACredentialSpecLength      = maxGMSACredentialSpecLengthInKiB * 1024
        maxRunAsUserNameDomainLength     = 256
        maxRunAsUserNameUserLength       = 104
)

var (
        // control characters are not permitted in the runAsUserName field.
        ctrlRegex = regexp.MustCompile(`[[:cntrl:]]+`)

        // a valid NetBios Domain name cannot start with a dot, has at least 1 character,
        // at most 15 characters, and it cannot the characters: \ / : * ? " < > |
        validNetBiosRegex = regexp.MustCompile(`^[^\\/:\*\?"<>|\.][^\\/:\*\?"<>|]{0,14}$`)

        // a valid DNS name contains only alphanumeric characters, dots, and dashes.
        dnsLabelFormat                 = `[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?`
        dnsSubdomainFormat             = fmt.Sprintf(`^%s(?:\.%s)*$`, dnsLabelFormat, dnsLabelFormat)
        validWindowsUserDomainDNSRegex = regexp.MustCompile(dnsSubdomainFormat)

        // a username is invalid if it contains the characters: " / \ [ ] : ; | = , + * ? < > @
        // or it contains only dots or spaces.
        invalidUserNameCharsRegex      = regexp.MustCompile(`["/\\:;|=,\+\*\?<>@\[\]]`)
        invalidUserNameDotsSpacesRegex = regexp.MustCompile(`^[\. ]+$`)
)

func validateWindowsSecurityContextOptions(windowsOptions *core.WindowsSecurityContextOptions, fieldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        if windowsOptions == nil {
                return allErrs
        }

        if windowsOptions.GMSACredentialSpecName != nil {
                // gmsaCredentialSpecName must be the name of a custom resource
                for _, msg := range validation.IsDNS1123Subdomain(*windowsOptions.GMSACredentialSpecName) {
                        allErrs = append(allErrs, field.Invalid(fieldPath.Child("gmsaCredentialSpecName"), windowsOptions.GMSACredentialSpecName, msg))
                }
        }

        if windowsOptions.GMSACredentialSpec != nil {
                if l := len(*windowsOptions.GMSACredentialSpec); l == 0 {
                        allErrs = append(allErrs, field.Invalid(fieldPath.Child("gmsaCredentialSpec"), windowsOptions.GMSACredentialSpec, "gmsaCredentialSpec cannot be an empty string"))
                } else if l > maxGMSACredentialSpecLength {
                        errMsg := fmt.Sprintf("gmsaCredentialSpec size must be under %d KiB", maxGMSACredentialSpecLengthInKiB)
                        allErrs = append(allErrs, field.Invalid(fieldPath.Child("gmsaCredentialSpec"), windowsOptions.GMSACredentialSpec, errMsg))
                }
        }

        if windowsOptions.RunAsUserName != nil {
                if l := len(*windowsOptions.RunAsUserName); l == 0 {
                        allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, "runAsUserName cannot be an empty string"))
                } else if ctrlRegex.MatchString(*windowsOptions.RunAsUserName) {
                        errMsg := "runAsUserName cannot contain control characters"
                        allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, errMsg))
                } else if parts := strings.Split(*windowsOptions.RunAsUserName, "\\"); len(parts) > 2 {
                        errMsg := "runAsUserName cannot contain more than one backslash"
                        allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, errMsg))
                } else {
                        var (
                                hasDomain = false
                                domain    = ""
                                user      string
                        )
                        if len(parts) == 1 {
                                user = parts[0]
                        } else {
                                hasDomain = true
                                domain = parts[0]
                                user = parts[1]
                        }

                        if len(domain) >= maxRunAsUserNameDomainLength {
                                errMsg := fmt.Sprintf("runAsUserName's Domain length must be under %d characters", maxRunAsUserNameDomainLength)
                                allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, errMsg))
                        }

                        if hasDomain && !(validNetBiosRegex.MatchString(domain) || validWindowsUserDomainDNSRegex.MatchString(domain)) {
                                errMsg := "runAsUserName's Domain doesn't match the NetBios nor the DNS format"
                                allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, errMsg))
                        }

                        if l := len(user); l == 0 {
                                errMsg := "runAsUserName's User cannot be empty"
                                allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, errMsg))
                        } else if l > maxRunAsUserNameUserLength {
                                errMsg := fmt.Sprintf("runAsUserName's User length must not be longer than %d characters", maxRunAsUserNameUserLength)
                                allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, errMsg))
                        }

                        if invalidUserNameDotsSpacesRegex.MatchString(user) {
                                errMsg := `runAsUserName's User cannot contain only periods or spaces`
                                allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, errMsg))
                        }

                        if invalidUserNameCharsRegex.MatchString(user) {
                                errMsg := `runAsUserName's User cannot contain the following characters: "/\:;|=,+*?<>@[]`
                                allErrs = append(allErrs, field.Invalid(fieldPath.Child("runAsUserName"), windowsOptions.RunAsUserName, errMsg))
                        }
                }
        }

        return allErrs
}

func validateWindowsHostProcessPod(podSpec *core.PodSpec, fieldPath *field.Path) field.ErrorList {
        allErrs := field.ErrorList{}

        // Keep track of container and hostProcess container count for validate
        containerCount := 0
        hostProcessContainerCount := 0

        var podHostProcess *bool
        if podSpec.SecurityContext != nil && podSpec.SecurityContext.WindowsOptions != nil {
                podHostProcess = podSpec.SecurityContext.WindowsOptions.HostProcess
        }

        hostNetwork := false
        if podSpec.SecurityContext != nil {
                hostNetwork = podSpec.SecurityContext.HostNetwork
        }

        podshelper.VisitContainersWithPath(podSpec, fieldPath, func(c *core.Container, cFieldPath *field.Path) bool {
                containerCount++

                var containerHostProcess *bool = nil
                if c.SecurityContext != nil && c.SecurityContext.WindowsOptions != nil {
                        containerHostProcess = c.SecurityContext.WindowsOptions.HostProcess
                }

                if podHostProcess != nil && containerHostProcess != nil && *podHostProcess != *containerHostProcess {
                        errMsg := fmt.Sprintf("pod hostProcess value must be identical if both are specified, was %v", *podHostProcess)
                        allErrs = append(allErrs, field.Invalid(cFieldPath.Child("securityContext", "windowsOptions", "hostProcess"), *containerHostProcess, errMsg))
                }

                switch {
                case containerHostProcess != nil && *containerHostProcess:
                        // Container explicitly sets hostProcess=true
                        hostProcessContainerCount++
                case containerHostProcess == nil && podHostProcess != nil && *podHostProcess:
                        // Container inherits hostProcess=true from pod settings
                        hostProcessContainerCount++
                }

                return true
        })

        if hostProcessContainerCount > 0 {
                // At present, if a Windows Pods contains any HostProcess containers than all containers must be
                // HostProcess containers (explicitly set or inherited).
                if hostProcessContainerCount != containerCount {
                        errMsg := "If pod contains any hostProcess containers then all containers must be HostProcess containers"
                        allErrs = append(allErrs, field.Invalid(fieldPath, "", errMsg))
                }

                // At present Windows Pods which contain HostProcess containers must also set HostNetwork.
                if !hostNetwork {
                        errMsg := "hostNetwork must be true if pod contains any hostProcess containers"
                        allErrs = append(allErrs, field.Invalid(fieldPath.Child("hostNetwork"), hostNetwork, errMsg))
                }

                if !capabilities.Get().AllowPrivileged {
                        errMsg := "hostProcess containers are disallowed by cluster policy"
                        allErrs = append(allErrs, field.Forbidden(fieldPath, errMsg))
                }
        }

        return allErrs
}

// validateOS validates the OS field within pod spec
func validateOS(podSpec *core.PodSpec, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        os := podSpec.OS
        if os == nil {
                return allErrs
        }
        if len(os.Name) == 0 {
                return append(allErrs, field.Required(fldPath.Child("name"), ""))
        }
        if !validOS.Has(os.Name) {
                allErrs = append(allErrs, field.NotSupported(fldPath, os.Name, sets.List(validOS)))
        }
        return allErrs
}

var validLogStreams = sets.New[string](
        core.LogStreamStdout,
        core.LogStreamStderr,
        core.LogStreamAll,
)

func ValidatePodLogOptions(opts *core.PodLogOptions, allowStreamSelection bool) field.ErrorList {
        allErrs := field.ErrorList{}
        if opts.TailLines != nil && *opts.TailLines < 0 {
                allErrs = append(allErrs, field.Invalid(field.NewPath("tailLines"), *opts.TailLines, isNegativeErrorMsg))
        }
        if opts.LimitBytes != nil && *opts.LimitBytes < 1 {
                allErrs = append(allErrs, field.Invalid(field.NewPath("limitBytes"), *opts.LimitBytes, "must be greater than 0"))
        }
        switch {
        case opts.SinceSeconds != nil && opts.SinceTime != nil:
                allErrs = append(allErrs, field.Forbidden(field.NewPath(""), "at most one of `sinceTime` or `sinceSeconds` may be specified"))
        case opts.SinceSeconds != nil:
                if *opts.SinceSeconds < 1 {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("sinceSeconds"), *opts.SinceSeconds, "must be greater than 0"))
                }
        }
        if allowStreamSelection {
                if opts.Stream == nil {
                        allErrs = append(allErrs, field.Required(field.NewPath("stream"), "must be specified"))
                } else {
                        if !validLogStreams.Has(*opts.Stream) {
                                allErrs = append(allErrs, field.NotSupported(field.NewPath("stream"), *opts.Stream, validLogStreams.UnsortedList()))
                        }
                        if *opts.Stream != core.LogStreamAll && opts.TailLines != nil {
                                allErrs = append(allErrs, field.Forbidden(field.NewPath(""), "`tailLines` and specific `stream` are mutually exclusive for now"))
                        }
                }
        } else if opts.Stream != nil {
                allErrs = append(allErrs, field.Forbidden(field.NewPath("stream"), "may not be specified"))
        }
        return allErrs
}

var (
        supportedLoadBalancerIPMode = sets.New(core.LoadBalancerIPModeVIP, core.LoadBalancerIPModeProxy)
)

// ValidateLoadBalancerStatus validates required fields on a LoadBalancerStatus
func ValidateLoadBalancerStatus(status, oldStatus *core.LoadBalancerStatus, fldPath *field.Path, spec *core.ServiceSpec) field.ErrorList {
        allErrs := field.ErrorList{}
        ingrPath := fldPath.Child("ingress")
        if !utilfeature.DefaultFeatureGate.Enabled(features.AllowServiceLBStatusOnNonLB) && spec.Type != core.ServiceTypeLoadBalancer && len(status.Ingress) != 0 {
                allErrs = append(allErrs, field.Forbidden(ingrPath, "may only be used when `spec.type` is 'LoadBalancer'"))
        } else {
                var existingIngressIPs []string
                if oldStatus != nil {
                        existingIngressIPs = make([]string, 0, len(oldStatus.Ingress))
                        for _, ingress := range oldStatus.Ingress {
                                if len(ingress.IP) > 0 {
                                        existingIngressIPs = append(existingIngressIPs, ingress.IP)
                                }
                        }
                }
                for i, ingress := range status.Ingress {
                        idxPath := ingrPath.Index(i)
                        if len(ingress.IP) > 0 {
                                allErrs = append(allErrs, IsValidIPForLegacyField(idxPath.Child("ip"), ingress.IP, existingIngressIPs)...)
                        }

                        if utilfeature.DefaultFeatureGate.Enabled(features.LoadBalancerIPMode) && ingress.IPMode == nil {
                                if len(ingress.IP) > 0 {
                                        allErrs = append(allErrs, field.Required(idxPath.Child("ipMode"), "must be specified when `ip` is set"))
                                }
                        } else if ingress.IPMode != nil && len(ingress.IP) == 0 {
                                allErrs = append(allErrs, field.Forbidden(idxPath.Child("ipMode"), "may not be specified when `ip` is not set"))
                        } else if ingress.IPMode != nil && !supportedLoadBalancerIPMode.Has(*ingress.IPMode) {
                                allErrs = append(allErrs, field.NotSupported(idxPath.Child("ipMode"), ingress.IPMode, sets.List(supportedLoadBalancerIPMode)))
                        }

                        if len(ingress.Hostname) > 0 {
                                for _, msg := range validation.IsDNS1123Subdomain(ingress.Hostname) {
                                        allErrs = append(allErrs, field.Invalid(idxPath.Child("hostname"), ingress.Hostname, msg))
                                }
                                if isIP := netutils.ParseIPSloppy(ingress.Hostname) != nil; isIP {
                                        allErrs = append(allErrs, field.Invalid(idxPath.Child("hostname"), ingress.Hostname, "must be a DNS name, not an IP address"))
                                }
                        }
                }
        }
        return allErrs
}

// validateVolumeNodeAffinity tests that the PersistentVolume.NodeAffinity has valid data
// returns:
// - true if volumeNodeAffinity is set
// - errorList if there are validation errors
func validateVolumeNodeAffinity(nodeAffinity *core.VolumeNodeAffinity, opts PersistentVolumeSpecValidationOptions, fldPath *field.Path) (bool, field.ErrorList) {
        allErrs := field.ErrorList{}

        if nodeAffinity == nil {
                return false, allErrs
        }

        if nodeAffinity.Required != nil {
                allErrs = append(allErrs, ValidateNodeSelector(nodeAffinity.Required, opts.AllowInvalidLabelValueInRequiredNodeAffinity, fldPath.Child("required"))...)
        } else {
                allErrs = append(allErrs, field.Required(fldPath.Child("required"), "must specify required node constraints"))
        }

        return true, allErrs
}

func IsDecremented(update, old *int32) bool {
        if update == nil && old != nil {
                return true
        }
        if update == nil || old == nil {
                return false
        }
        return *update < *old
}

// ValidateProcMountType tests that the argument is a valid ProcMountType.
func ValidateProcMountType(fldPath *field.Path, procMountType core.ProcMountType) *field.Error {
        switch procMountType {
        case core.DefaultProcMount, core.UnmaskedProcMount:
                return nil
        default:
                return field.NotSupported(fldPath, procMountType, []core.ProcMountType{core.DefaultProcMount, core.UnmaskedProcMount})
        }
}

var (
        supportedScheduleActions = sets.New(core.DoNotSchedule, core.ScheduleAnyway)
)

// validateTopologySpreadConstraints validates given TopologySpreadConstraints.
func validateTopologySpreadConstraints(constraints []core.TopologySpreadConstraint, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}

        for i, constraint := range constraints {
                subFldPath := fldPath.Index(i)
                if errs := ValidatePositiveField(int64(constraint.MaxSkew), subFldPath.Child("maxSkew")); len(errs) > 0 {
                        allErrs = append(allErrs, errs...)
                }
                if err := ValidateTopologyKey(subFldPath.Child("topologyKey"), constraint.TopologyKey); err != nil {
                        allErrs = append(allErrs, err)
                }
                if err := ValidateWhenUnsatisfiable(subFldPath.Child("whenUnsatisfiable"), constraint.WhenUnsatisfiable); err != nil {
                        allErrs = append(allErrs, err)
                }
                // tuple {topologyKey, whenUnsatisfiable} denotes one kind of spread constraint
                if err := ValidateSpreadConstraintNotRepeat(subFldPath.Child("{topologyKey, whenUnsatisfiable}"), constraint, constraints[i+1:]); err != nil {
                        allErrs = append(allErrs, err)
                }
                allErrs = append(allErrs, validateMinDomains(subFldPath.Child("minDomains"), constraint.MinDomains, constraint.WhenUnsatisfiable)...)
                if err := validateNodeInclusionPolicy(subFldPath.Child("nodeAffinityPolicy"), constraint.NodeAffinityPolicy); err != nil {
                        allErrs = append(allErrs, err)
                }
                if err := validateNodeInclusionPolicy(subFldPath.Child("nodeTaintsPolicy"), constraint.NodeTaintsPolicy); err != nil {
                        allErrs = append(allErrs, err)
                }
                // legacyValidationFunction is ValidateMatchLabelKeysInTopologySpread
                // preferredValidationFunction is ValidateMatchLabelKeysAndMismatchLabelKeys
                // OldPodViolatesMatchLabelKeysValidation==true means ValidateMatchLabelKeysAndMismatchLabelKeys failed, which means preferredValidation failed
                // OldPodViolatesLegacyMatchLabelKeysValidation==true means ValidateMatchLabelKeysInTopologySpread failed, which means legacyValidation failed
                if opts.AllowMatchLabelKeysInPodTopologySpread {
                        switch {
                        case opts.AllowMatchLabelKeysInPodTopologySpreadSelectorMerge && opts.OldPodViolatesMatchLabelKeysValidation:
                                // This case means that we want to use the preferredValidationFunction, but the old pod doesn't pass the preferredValidationFunction, so it must continue using the legacyValidationFunction.
                                // This is because we don't allow the fields to change.
                                allErrs = append(allErrs, ValidateMatchLabelKeysInTopologySpread(subFldPath.Child("matchLabelKeys"), constraint.MatchLabelKeys, constraint.LabelSelector)...)
                        case opts.AllowMatchLabelKeysInPodTopologySpreadSelectorMerge && !opts.OldPodViolatesMatchLabelKeysValidation:
                                // This case means we want to use the preferredValidationFunction and the old pod passes it, so we will continue requiring the preferredValidationFunction to pass.
                                allErrs = append(allErrs, ValidateMatchLabelKeysAndMismatchLabelKeys(subFldPath, constraint.MatchLabelKeys, nil, constraint.LabelSelector)...)
                        case !opts.AllowMatchLabelKeysInPodTopologySpreadSelectorMerge && opts.OldPodViolatesLegacyMatchLabelKeysValidation:
                                // This case means we want to use the legacyValidationFunction, but the old pod doesn't pass it, so it must continue using the preferredValidationFunction instead so that updates to other fields can happen.
                                // This allows us to enable the featuregate, then disable the featuregate and still be able to update the pod.
                                allErrs = append(allErrs, ValidateMatchLabelKeysAndMismatchLabelKeys(subFldPath, constraint.MatchLabelKeys, nil, constraint.LabelSelector)...)
                        case !opts.AllowMatchLabelKeysInPodTopologySpreadSelectorMerge && !opts.OldPodViolatesLegacyMatchLabelKeysValidation:
                                // This case means we want to use the legacyValidationFunction and the old pod passes it, so we will continue requiring the legacyValidationFunction to pass.
                                allErrs = append(allErrs, ValidateMatchLabelKeysInTopologySpread(subFldPath.Child("matchLabelKeys"), constraint.MatchLabelKeys, constraint.LabelSelector)...)
                        default:
                                // If we fall through, then we use the legacyValidationFunction because that's what we did prior to the featuregate(MatchLabelKeysInPodTopologySpreadSelectorMerge).
                                allErrs = append(allErrs, ValidateMatchLabelKeysInTopologySpread(subFldPath.Child("matchLabelKeys"), constraint.MatchLabelKeys, constraint.LabelSelector)...)
                        }
                } else {
                        allErrs = append(allErrs, ValidateMatchLabelKeysInTopologySpread(subFldPath.Child("matchLabelKeys"), constraint.MatchLabelKeys, constraint.LabelSelector)...)
                }
                if !opts.AllowInvalidTopologySpreadConstraintLabelSelector {
                        allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(constraint.LabelSelector, unversionedvalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: false}, subFldPath.Child("labelSelector"))...)
                }
        }

        return allErrs
}

// validateMinDomains tests that the argument is a valid MinDomains.
func validateMinDomains(fldPath *field.Path, minDomains *int32, action core.UnsatisfiableConstraintAction) field.ErrorList {
        if minDomains == nil {
                return nil
        }
        var allErrs field.ErrorList
        allErrs = append(allErrs, ValidatePositiveField(int64(*minDomains), fldPath)...)
        // When MinDomains is non-nil, whenUnsatisfiable must be DoNotSchedule.
        if action != core.DoNotSchedule {
                allErrs = append(allErrs, field.Invalid(fldPath, minDomains, fmt.Sprintf("can only use minDomains if whenUnsatisfiable=%s, not %s", core.DoNotSchedule, action)).WithOrigin("dependsOn"))
        }
        return allErrs
}

// ValidateTopologyKey tests that the argument is a valid TopologyKey.
func ValidateTopologyKey(fldPath *field.Path, topologyKey string) *field.Error {
        if len(topologyKey) == 0 {
                return field.Required(fldPath, "can not be empty")
        }
        return nil
}

// ValidateWhenUnsatisfiable tests that the argument is a valid UnsatisfiableConstraintAction.
func ValidateWhenUnsatisfiable(fldPath *field.Path, action core.UnsatisfiableConstraintAction) *field.Error {
        if !supportedScheduleActions.Has(action) {
                return field.NotSupported(fldPath, action, sets.List(supportedScheduleActions))
        }
        return nil
}

// ValidateSpreadConstraintNotRepeat tests that if `constraint` duplicates with `existingConstraintPairs`
// on TopologyKey and WhenUnsatisfiable fields.
func ValidateSpreadConstraintNotRepeat(fldPath *field.Path, constraint core.TopologySpreadConstraint, restingConstraints []core.TopologySpreadConstraint) *field.Error {
        for _, restingConstraint := range restingConstraints {
                if constraint.TopologyKey == restingConstraint.TopologyKey &&
                        constraint.WhenUnsatisfiable == restingConstraint.WhenUnsatisfiable {
                        return field.Duplicate(fldPath, fmt.Sprintf("{%v, %v}", constraint.TopologyKey, constraint.WhenUnsatisfiable))
                }
        }
        return nil
}

var (
        supportedPodTopologySpreadNodePolicies = sets.New(core.NodeInclusionPolicyIgnore, core.NodeInclusionPolicyHonor)
)

// validateNodeInclusionPolicy tests that the argument is a valid NodeInclusionPolicy.
func validateNodeInclusionPolicy(fldPath *field.Path, policy *core.NodeInclusionPolicy) *field.Error {
        if policy == nil {
                return nil
        }

        if !supportedPodTopologySpreadNodePolicies.Has(*policy) {
                return field.NotSupported(fldPath, policy, sets.List(supportedPodTopologySpreadNodePolicies))
        }
        return nil
}

// ValidateMatchLabelKeysAndMismatchLabelKeys checks if both matchLabelKeys and mismatchLabelKeys are valid.
// - validate that all matchLabelKeys and mismatchLabelKeys are valid label names.
// - validate that the user doens't specify the same key in both matchLabelKeys and labelSelector.
// - validate that any matchLabelKeys are not duplicated with mismatchLabelKeys.
func ValidateMatchLabelKeysAndMismatchLabelKeys(fldPath *field.Path, matchLabelKeys, mismatchLabelKeys []string, labelSelector *metav1.LabelSelector) field.ErrorList {
        var allErrs field.ErrorList
        // 1. validate that all matchLabelKeys and mismatchLabelKeys are valid label names.
        allErrs = append(allErrs, validateLabelKeys(fldPath.Child("matchLabelKeys"), matchLabelKeys, labelSelector)...)
        allErrs = append(allErrs, validateLabelKeys(fldPath.Child("mismatchLabelKeys"), mismatchLabelKeys, labelSelector)...)

        // 2. validate that the user doens't specify the same key in both matchLabelKeys and labelSelector.
        // It doesn't make sense to have the labelselector with the key specified in matchLabelKeys
        // because the matchLabelKeys will be `In` labelSelector which matches with only one value in the key
        // and we cannot make any further filtering with that key.
        // On the other hand, we may want to have labelSelector with the key specified in mismatchLabelKeys.
        // because the mismatchLabelKeys will be `NotIn` labelSelector
        // and we may want to filter Pods further with other labelSelector with that key.

        // labelKeysMap is keyed by label key and valued by the index of label key in labelKeys.
        if labelSelector != nil {
                labelKeysMap := map[string]int{}
                for i, key := range matchLabelKeys {
                        labelKeysMap[key] = i
                }
                labelSelectorKeys := sets.New[string]()
                for key := range labelSelector.MatchLabels {
                        labelSelectorKeys.Insert(key)
                }
                for _, matchExpression := range labelSelector.MatchExpressions {
                        key := matchExpression.Key
                        if i, ok := labelKeysMap[key]; ok && labelSelectorKeys.Has(key) {
                                // Before validateLabelKeysWithSelector is called, the labelSelector has already got the selector created from matchLabelKeys.
                                // Here, we found the duplicate key in labelSelector and the key is specified in labelKeys.
                                // Meaning that the same key is specified in both labelSelector and matchLabelKeys/mismatchLabelKeys.
                                allErrs = append(allErrs, field.Invalid(fldPath.Index(i), key, "exists in both matchLabelKeys and labelSelector").WithOrigin("duplicatedLabelKeys"))
                        }

                        labelSelectorKeys.Insert(key)
                }
        }

        // 3. validate that any matchLabelKeys are not duplicated with mismatchLabelKeys.
        mismatchLabelKeysSet := sets.New(mismatchLabelKeys...)
        for i, k := range matchLabelKeys {
                if mismatchLabelKeysSet.Has(k) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Child("matchLabelKeys").Index(i), k, "exists in both matchLabelKeys and mismatchLabelKeys").WithOrigin("duplicatedMismatchLabelKeys"))
                }
        }

        return allErrs
}

// ValidateMatchLabelKeysInTopologySpread tests that the elements are a valid label name and are not already included in labelSelector.
func ValidateMatchLabelKeysInTopologySpread(fldPath *field.Path, matchLabelKeys []string, labelSelector *metav1.LabelSelector) field.ErrorList {
        if len(matchLabelKeys) == 0 {
                return nil
        }

        var allErrs field.ErrorList
        labelSelectorKeys := sets.Set[string]{}

        if labelSelector != nil {
                for key := range labelSelector.MatchLabels {
                        labelSelectorKeys.Insert(key)
                }
                for _, matchExpression := range labelSelector.MatchExpressions {
                        labelSelectorKeys.Insert(matchExpression.Key)
                }
        } else {
                allErrs = append(allErrs, field.Forbidden(fldPath, "must not be specified when labelSelector is not set"))
        }

        for i, key := range matchLabelKeys {
                allErrs = append(allErrs, unversionedvalidation.ValidateLabelName(key, fldPath.Index(i))...)
                if labelSelectorKeys.Has(key) {
                        allErrs = append(allErrs, field.Invalid(fldPath.Index(i), key, "exists in both matchLabelKeys and labelSelector").WithOrigin("duplicatedLabelKeys"))
                }
        }

        return allErrs
}

// validateLabelKeys tests that the label keys are a valid label name.
// It's intended to be used for matchLabelKeys or mismatchLabelKeys.
func validateLabelKeys(fldPath *field.Path, labelKeys []string, labelSelector *metav1.LabelSelector) field.ErrorList {
        if len(labelKeys) == 0 {
                return nil
        }

        if labelSelector == nil {
                return field.ErrorList{field.Forbidden(fldPath, "must not be specified when labelSelector is not set")}
        }

        var allErrs field.ErrorList
        for i, key := range labelKeys {
                allErrs = append(allErrs, unversionedvalidation.ValidateLabelName(key, fldPath.Index(i))...)
        }

        return allErrs
}

// ValidateServiceClusterIPsRelatedFields validates .spec.ClusterIPs,,
// .spec.IPFamilies, .spec.ipFamilyPolicy.  This is exported because it is used
// during IP init and allocation.
func ValidateServiceClusterIPsRelatedFields(service, oldService *core.Service) field.ErrorList {
        // ClusterIP, ClusterIPs, IPFamilyPolicy and IPFamilies are validated prior (all must be unset) for ExternalName service
        if service.Spec.Type == core.ServiceTypeExternalName {
                return field.ErrorList{}
        }

        allErrs := field.ErrorList{}
        hasInvalidIPs := false

        specPath := field.NewPath("spec")
        clusterIPsField := specPath.Child("clusterIPs")
        ipFamiliesField := specPath.Child("ipFamilies")
        ipFamilyPolicyField := specPath.Child("ipFamilyPolicy")

        // Make sure ClusterIP and ClusterIPs are synced.  For most cases users can
        // just manage one or the other and we'll handle the rest (see PrepareFor*
        // in strategy).
        if len(service.Spec.ClusterIP) != 0 {
                // If ClusterIP is set, ClusterIPs[0] must match.
                if len(service.Spec.ClusterIPs) == 0 {
                        allErrs = append(allErrs, field.Required(clusterIPsField, ""))
                } else if service.Spec.ClusterIPs[0] != service.Spec.ClusterIP {
                        allErrs = append(allErrs, field.Invalid(clusterIPsField, service.Spec.ClusterIPs, "first value must match `clusterIP`"))
                }
        } else { // ClusterIP == ""
                // If ClusterIP is not set, ClusterIPs must also be unset.
                if len(service.Spec.ClusterIPs) != 0 {
                        allErrs = append(allErrs, field.Invalid(clusterIPsField, service.Spec.ClusterIPs, "must be empty when `clusterIP` is not specified"))
                }
        }

        // ipfamilies stand alone validation
        // must be either IPv4 or IPv6
        seen := sets.Set[core.IPFamily]{}
        for i, ipFamily := range service.Spec.IPFamilies {
                if !supportedServiceIPFamily.Has(ipFamily) {
                        allErrs = append(allErrs, field.NotSupported(ipFamiliesField.Index(i), ipFamily, sets.List(supportedServiceIPFamily)))
                }
                // no duplicate check also ensures that ipfamilies is dualstacked, in any order
                if seen.Has(ipFamily) {
                        allErrs = append(allErrs, field.Duplicate(ipFamiliesField.Index(i), ipFamily))
                }
                seen.Insert(ipFamily)
        }

        // IPFamilyPolicy stand alone validation
        // note: nil is ok, defaulted in alloc check registry/core/service/*
        if service.Spec.IPFamilyPolicy != nil {
                // must have a supported value
                if !supportedServiceIPFamilyPolicy.Has(*(service.Spec.IPFamilyPolicy)) {
                        allErrs = append(allErrs, field.NotSupported(ipFamilyPolicyField, service.Spec.IPFamilyPolicy, sets.List(supportedServiceIPFamilyPolicy)))
                }
        }

        var existingClusterIPs []string
        if oldService != nil {
                existingClusterIPs = oldService.Spec.ClusterIPs // +k8s:verify-mutation:reason=clone
        }

        // clusterIPs stand alone validation
        // valid ips with None and empty string handling
        // duplication check is done as part of DualStackvalidation below
        for i, clusterIP := range service.Spec.ClusterIPs {
                // valid at first location only. if and only if len(clusterIPs) == 1
                if i == 0 && clusterIP == core.ClusterIPNone {
                        if len(service.Spec.ClusterIPs) > 1 {
                                hasInvalidIPs = true
                                allErrs = append(allErrs, field.Invalid(clusterIPsField, service.Spec.ClusterIPs, "'None' must be the first and only value"))
                        }
                        continue
                }

                // is it a valid ip? (or was it at least previously considered valid?)
                errorMessages := IsValidIPForLegacyField(clusterIPsField.Index(i), clusterIP, existingClusterIPs)
                hasInvalidIPs = (len(errorMessages) != 0) || hasInvalidIPs
                allErrs = append(allErrs, errorMessages...)
        }

        // max two
        if len(service.Spec.ClusterIPs) > 2 {
                allErrs = append(allErrs, field.Invalid(clusterIPsField, service.Spec.ClusterIPs, "may only hold up to 2 values"))
        }

        // at this stage if there is an invalid ip or misplaced none/empty string
        // it will skew the error messages (bad index || dualstackness of already bad ips). so we
        // stop here if there are errors in clusterIPs validation
        if hasInvalidIPs {
                return allErrs
        }

        // must be dual stacked ips if they are more than one ip
        if len(service.Spec.ClusterIPs) > 1 /* meaning: it does not have a None or empty string */ {
                dualStack, err := netutils.IsDualStackIPStrings(service.Spec.ClusterIPs)
                if err != nil { // though we check for that earlier. safe > sorry
                        allErrs = append(allErrs, field.InternalError(clusterIPsField, fmt.Errorf("failed to check for dual stack with error:%v", err)))
                }

                // We only support one from each IP family (i.e. max two IPs in this list).
                if !dualStack {
                        allErrs = append(allErrs, field.Invalid(clusterIPsField, service.Spec.ClusterIPs, "may specify no more than one IP for each IP family"))
                }
        }

        // match clusterIPs to their families, if they were provided
        if !isHeadlessService(service) && len(service.Spec.ClusterIPs) > 0 && len(service.Spec.IPFamilies) > 0 {
                for i, ip := range service.Spec.ClusterIPs {
                        if i > (len(service.Spec.IPFamilies) - 1) {
                                break // no more families to check
                        }

                        // 4=>6
                        if service.Spec.IPFamilies[i] == core.IPv4Protocol && netutils.IsIPv6String(ip) {
                                allErrs = append(allErrs, field.Invalid(clusterIPsField.Index(i), ip, fmt.Sprintf("expected an IPv4 value as indicated by `ipFamilies[%v]`", i)))
                        }
                        // 6=>4
                        if service.Spec.IPFamilies[i] == core.IPv6Protocol && !netutils.IsIPv6String(ip) {
                                allErrs = append(allErrs, field.Invalid(clusterIPsField.Index(i), ip, fmt.Sprintf("expected an IPv6 value as indicated by `ipFamilies[%v]`", i)))
                        }
                }
        }

        return allErrs
}

// specific validation for clusterIPs in cases of user upgrading or downgrading to/from dualstack
func validateUpgradeDowngradeClusterIPs(oldService, service *core.Service) field.ErrorList {
        allErrs := make(field.ErrorList, 0)

        // bail out early for ExternalName
        if service.Spec.Type == core.ServiceTypeExternalName || oldService.Spec.Type == core.ServiceTypeExternalName {
                return allErrs
        }
        newIsHeadless := isHeadlessService(service)
        oldIsHeadless := isHeadlessService(oldService)

        if oldIsHeadless && newIsHeadless {
                return allErrs
        }

        switch {
        // no change in ClusterIP lengths
        // compare each
        case len(oldService.Spec.ClusterIPs) == len(service.Spec.ClusterIPs):
                for i, ip := range oldService.Spec.ClusterIPs {
                        if ip != service.Spec.ClusterIPs[i] {
                                allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "clusterIPs").Index(i), service.Spec.ClusterIPs, "may not change once set"))
                        }
                }

        // something has been released (downgraded)
        case len(oldService.Spec.ClusterIPs) > len(service.Spec.ClusterIPs):
                // primary ClusterIP has been released
                if len(service.Spec.ClusterIPs) == 0 {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "clusterIPs").Index(0), service.Spec.ClusterIPs, "primary clusterIP can not be unset"))
                }

                // test if primary clusterIP has changed
                if len(oldService.Spec.ClusterIPs) > 0 &&
                        len(service.Spec.ClusterIPs) > 0 &&
                        service.Spec.ClusterIPs[0] != oldService.Spec.ClusterIPs[0] {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "clusterIPs").Index(0), service.Spec.ClusterIPs, "may not change once set"))
                }

                // test if secondary ClusterIP has been released. has this service been downgraded correctly?
                // user *must* set IPFamilyPolicy == SingleStack
                if len(service.Spec.ClusterIPs) == 1 {
                        if service.Spec.IPFamilyPolicy == nil || *(service.Spec.IPFamilyPolicy) != core.IPFamilyPolicySingleStack {
                                allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "ipFamilyPolicy"), service.Spec.IPFamilyPolicy, "must be set to 'SingleStack' when releasing the secondary clusterIP"))
                        }
                }
        case len(oldService.Spec.ClusterIPs) < len(service.Spec.ClusterIPs):
                // something has been added (upgraded)
                // test if primary clusterIP has changed
                if len(oldService.Spec.ClusterIPs) > 0 &&
                        service.Spec.ClusterIPs[0] != oldService.Spec.ClusterIPs[0] {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "clusterIPs").Index(0), service.Spec.ClusterIPs, "may not change once set"))
                }
                // we don't check for Policy == RequireDualStack here since, Validation/Creation func takes care of it
        }
        return allErrs
}

// specific validation for ipFamilies in cases of user upgrading or downgrading to/from dualstack
func validateUpgradeDowngradeIPFamilies(oldService, service *core.Service) field.ErrorList {
        allErrs := make(field.ErrorList, 0)
        // bail out early for ExternalName
        if service.Spec.Type == core.ServiceTypeExternalName || oldService.Spec.Type == core.ServiceTypeExternalName {
                return allErrs
        }

        oldIsHeadless := isHeadlessService(oldService)
        newIsHeadless := isHeadlessService(service)

        // if changed to/from headless, then bail out
        if newIsHeadless != oldIsHeadless {
                return allErrs
        }
        // headless can change families
        if newIsHeadless {
                return allErrs
        }

        switch {
        case len(oldService.Spec.IPFamilies) == len(service.Spec.IPFamilies):
                // no change in ClusterIP lengths
                // compare each

                for i, ip := range oldService.Spec.IPFamilies {
                        if ip != service.Spec.IPFamilies[i] {
                                allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "ipFamilies").Index(0), service.Spec.IPFamilies, "may not change once set"))
                        }
                }

        case len(oldService.Spec.IPFamilies) > len(service.Spec.IPFamilies):
                // something has been released (downgraded)

                // test if primary ipfamily has been released
                if len(service.Spec.ClusterIPs) == 0 {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "ipFamilies").Index(0), service.Spec.IPFamilies, "primary ipFamily can not be unset"))
                }

                // test if primary ipFamily has changed
                if len(service.Spec.IPFamilies) > 0 &&
                        service.Spec.IPFamilies[0] != oldService.Spec.IPFamilies[0] {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "ipFamilies").Index(0), service.Spec.ClusterIPs, "may not change once set"))
                }

                // test if secondary IPFamily has been released. has this service been downgraded correctly?
                // user *must* set IPFamilyPolicy == SingleStack
                if len(service.Spec.IPFamilies) == 1 {
                        if service.Spec.IPFamilyPolicy == nil || *(service.Spec.IPFamilyPolicy) != core.IPFamilyPolicySingleStack {
                                allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "ipFamilyPolicy"), service.Spec.IPFamilyPolicy, "must be set to 'SingleStack' when releasing the secondary ipFamily"))
                        }
                }
        case len(oldService.Spec.IPFamilies) < len(service.Spec.IPFamilies):
                // something has been added (upgraded)

                // test if primary ipFamily has changed
                if len(oldService.Spec.IPFamilies) > 0 &&
                        len(service.Spec.IPFamilies) > 0 &&
                        service.Spec.IPFamilies[0] != oldService.Spec.IPFamilies[0] {
                        allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "ipFamilies").Index(0), service.Spec.ClusterIPs, "may not change once set"))
                }
                // we don't check for Policy == RequireDualStack here since, Validation/Creation func takes care of it
        }
        return allErrs
}

func isHeadlessService(service *core.Service) bool {
        return service != nil &&
                len(service.Spec.ClusterIPs) == 1 &&
                service.Spec.ClusterIPs[0] == core.ClusterIPNone
}

// validateLoadBalancerClassField validation for loadBalancerClass
func validateLoadBalancerClassField(oldService, service *core.Service) field.ErrorList {
        allErrs := make(field.ErrorList, 0)
        if oldService != nil {
                // validate update op
                if isTypeLoadBalancer(oldService) && isTypeLoadBalancer(service) {
                        // old and new are both LoadBalancer
                        if !sameLoadBalancerClass(oldService, service) {
                                // can't change loadBalancerClass
                                allErrs = append(allErrs, field.Invalid(field.NewPath("spec", "loadBalancerClass"), service.Spec.LoadBalancerClass, "may not change once set"))
                        }
                }
        }

        if isTypeLoadBalancer(service) {
                // check LoadBalancerClass format
                if service.Spec.LoadBalancerClass != nil {
                        allErrs = append(allErrs, ValidateQualifiedName(*service.Spec.LoadBalancerClass, field.NewPath("spec", "loadBalancerClass"))...)
                }
        } else {
                // check if LoadBalancerClass set for non LoadBalancer type of service
                if service.Spec.LoadBalancerClass != nil {
                        allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "loadBalancerClass"), "may only be used when `type` is 'LoadBalancer'"))
                }
        }
        return allErrs
}

// isTypeLoadBalancer tests service type is loadBalancer or not
func isTypeLoadBalancer(service *core.Service) bool {
        return service.Spec.Type == core.ServiceTypeLoadBalancer
}

// sameLoadBalancerClass check two services have the same loadBalancerClass or not
func sameLoadBalancerClass(oldService, service *core.Service) bool {
        if oldService.Spec.LoadBalancerClass == nil && service.Spec.LoadBalancerClass == nil {
                return true
        }
        if oldService.Spec.LoadBalancerClass == nil || service.Spec.LoadBalancerClass == nil {
                return false
        }
        return *oldService.Spec.LoadBalancerClass == *service.Spec.LoadBalancerClass
}

func ValidatePodAffinityTermSelector(podAffinityTerm core.PodAffinityTerm, allowInvalidLabelValueInSelector bool, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        labelSelectorValidationOptions := unversionedvalidation.LabelSelectorValidationOptions{AllowInvalidLabelValueInSelector: allowInvalidLabelValueInSelector}
        allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(podAffinityTerm.LabelSelector, labelSelectorValidationOptions, fldPath.Child("labelSelector"))...)
        allErrs = append(allErrs, unversionedvalidation.ValidateLabelSelector(podAffinityTerm.NamespaceSelector, labelSelectorValidationOptions, fldPath.Child("namespaceSelector"))...)
        return allErrs
}

var betaToGALabel = map[string]string{
        v1.LabelFailureDomainBetaZone:   v1.LabelTopologyZone,
        v1.LabelFailureDomainBetaRegion: v1.LabelTopologyRegion,
        kubeletapis.LabelOS:             v1.LabelOSStable,
        kubeletapis.LabelArch:           v1.LabelArchStable,
        v1.LabelInstanceType:            v1.LabelInstanceTypeStable,
}

var (
        maskNodeSelectorLabelChangeEqualities     conversion.Equalities
        initMaskNodeSelectorLabelChangeEqualities sync.Once
)

func getMaskNodeSelectorLabelChangeEqualities() conversion.Equalities {
        initMaskNodeSelectorLabelChangeEqualities.Do(func() {
                var eqs = apiequality.Semantic.Copy()
                err := eqs.AddFunc(
                        func(newReq, oldReq core.NodeSelectorRequirement) bool {
                                // allow newReq to change to a GA key
                                if oldReq.Key != newReq.Key && betaToGALabel[oldReq.Key] == newReq.Key {
                                        oldReq.Key = newReq.Key // +k8s:verify-mutation:reason=clone
                                }
                                return apiequality.Semantic.DeepEqual(newReq, oldReq)
                        },
                )
                if err != nil {
                        panic(fmt.Errorf("failed to instantiate semantic equalities: %w", err))
                }
                maskNodeSelectorLabelChangeEqualities = eqs
        })
        return maskNodeSelectorLabelChangeEqualities
}

func validatePvNodeAffinity(newPvNodeAffinity, oldPvNodeAffinity *core.VolumeNodeAffinity, fldPath *field.Path) field.ErrorList {
        var allErrs field.ErrorList
        if !getMaskNodeSelectorLabelChangeEqualities().DeepEqual(newPvNodeAffinity, oldPvNodeAffinity) {
                allErrs = append(allErrs, field.Invalid(fldPath, newPvNodeAffinity, fieldImmutableErrorMsg+", except for updating from beta label to GA"))
        }
        return allErrs
}

func validateNodeSelectorMutation(fldPath *field.Path, newNodeSelector, oldNodeSelector map[string]string) field.ErrorList {
        var allErrs field.ErrorList

        // Validate no existing node selectors were deleted or mutated.
        for k, v1 := range oldNodeSelector {
                if v2, ok := newNodeSelector[k]; !ok || v1 != v2 {
                        allErrs = append(allErrs, field.Invalid(fldPath, newNodeSelector, "only additions to spec.nodeSelector are allowed (no mutations or deletions)"))
                        return allErrs
                }
        }
        return allErrs
}

func validateNodeAffinityMutation(nodeAffinityPath *field.Path, newNodeAffinity, oldNodeAffinity *core.NodeAffinity) field.ErrorList {
        var allErrs field.ErrorList
        // If old node affinity was nil, anything can be set.
        if oldNodeAffinity == nil || oldNodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution == nil {
                return allErrs
        }

        oldTerms := oldNodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms
        var newTerms []core.NodeSelectorTerm
        if newNodeAffinity != nil && newNodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil {
                newTerms = newNodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms
        }

        // If there are no old terms, we can set the new terms to anything.
        // If there are old terms, we cannot add any new ones.
        if len(oldTerms) > 0 && len(oldTerms) != len(newTerms) {
                return append(allErrs, field.Invalid(nodeAffinityPath.Child("requiredDuringSchedulingIgnoredDuringExecution").Child("nodeSelectorTerms"), newTerms, "no additions/deletions to non-empty NodeSelectorTerms list are allowed"))
        }

        // For requiredDuringSchedulingIgnoredDuringExecution, if old NodeSelectorTerms
        // was empty, anything can be set. If non-empty, only additions of NodeSelectorRequirements
        // to matchExpressions or fieldExpressions are allowed.
        for i := range oldTerms {
                if !validateNodeSelectorTermHasOnlyAdditions(newTerms[i], oldTerms[i]) {
                        allErrs = append(allErrs, field.Invalid(nodeAffinityPath.Child("requiredDuringSchedulingIgnoredDuringExecution").Child("nodeSelectorTerms").Index(i), newTerms[i], "only additions are allowed (no mutations or deletions)"))
                }
        }
        return allErrs
}

func validateNodeSelectorTermHasOnlyAdditions(newTerm, oldTerm core.NodeSelectorTerm) bool {
        if len(oldTerm.MatchExpressions) == 0 && len(oldTerm.MatchFields) == 0 {
                if len(newTerm.MatchExpressions) > 0 || len(newTerm.MatchFields) > 0 {
                        return false
                }
        }

        // Validate MatchExpressions only has additions (no deletions or mutations)
        if l := len(oldTerm.MatchExpressions); l > 0 {
                if len(newTerm.MatchExpressions) < l {
                        return false
                }
                if !apiequality.Semantic.DeepEqual(newTerm.MatchExpressions[:l], oldTerm.MatchExpressions) {
                        return false
                }
        }
        // Validate MatchFields only has additions (no deletions or mutations)
        if l := len(oldTerm.MatchFields); l > 0 {
                if len(newTerm.MatchFields) < l {
                        return false
                }
                if !apiequality.Semantic.DeepEqual(newTerm.MatchFields[:l], oldTerm.MatchFields) {
                        return false
                }
        }
        return true
}

var validSupplementalGroupsPolicies = sets.New(core.SupplementalGroupsPolicyMerge, core.SupplementalGroupsPolicyStrict)

func validateSupplementalGroupsPolicy(supplementalGroupsPolicy *core.SupplementalGroupsPolicy, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        if !validSupplementalGroupsPolicies.Has(*supplementalGroupsPolicy) {
                allErrors = append(allErrors, field.NotSupported(fldPath, supplementalGroupsPolicy, sets.List(validSupplementalGroupsPolicies)))
        }
        return allErrors
}

func validateContainerStatusUsers(containerStatuses []core.ContainerStatus, fldPath *field.Path, podOS *core.PodOS) field.ErrorList {
        allErrors := field.ErrorList{}
        osName := core.Linux
        if podOS != nil {
                osName = podOS.Name
        }
        for i, containerStatus := range containerStatuses {
                if containerStatus.User == nil {
                        continue
                }
                containerUser := containerStatus.User
                switch osName {
                case core.Windows:
                        if containerUser.Linux != nil {
                                allErrors = append(allErrors, field.Forbidden(fldPath.Index(i).Child("user").Child("linux"), "cannot be set for a windows pod"))
                        }
                case core.Linux:
                        allErrors = append(allErrors, validateLinuxContainerUser(containerUser.Linux, fldPath.Index(i).Child("user").Child("linux"))...)
                }
        }
        return allErrors
}

func validateContainerStatusNoAllocatedResourcesStatus(containerStatuses []core.ContainerStatus, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}

        for i, containerStatus := range containerStatuses {
                if len(containerStatus.AllocatedResourcesStatus) == 0 {
                        continue
                }
                allErrors = append(allErrors, field.Forbidden(fldPath.Index(i).Child("allocatedResourcesStatus"), "must not be specified in container status"))
        }

        return allErrors
}

// validateContainerStatusAllocatedResourcesStatus iterate the allocated resources health and validate:
// - resourceName matches one of resources in container's resource requirements
// - resourceID is not empty and unique
func validateContainerStatusAllocatedResourcesStatus(containerStatuses []core.ContainerStatus, fldPath *field.Path, containers []core.Container) field.ErrorList {
        allErrors := field.ErrorList{}

        for i, containerStatus := range containerStatuses {
                if containerStatus.AllocatedResourcesStatus == nil {
                        continue
                }

                allocatedResources := containerStatus.AllocatedResourcesStatus
                for j, allocatedResource := range allocatedResources {
                        var container core.Container
                        containerFound := false
                        // get container by name
                        for _, c := range containers {
                                if c.Name == containerStatus.Name {
                                        containerFound = true
                                        container = c
                                        break
                                }
                        }

                        // ignore missing container, see https://github.com/kubernetes/kubernetes/issues/124915
                        if containerFound {
                                found := false
                                var errorStr string

                                if strings.HasPrefix(string(allocatedResource.Name), "claim:") {
                                        // assume it is a claim name

                                        errorStr = "must match one of the container's resource claims in a format 'claim:<claimName>/<request>' or 'claim:<claimName>' if request is empty"

                                        for _, c := range container.Resources.Claims {
                                                name := "claim:" + c.Name
                                                if c.Request != "" {
                                                        name += "/" + c.Request
                                                }

                                                if name == string(allocatedResource.Name) {
                                                        found = true
                                                        break
                                                }
                                        }

                                } else {
                                        // assume it is a resource name

                                        errorStr = "must match one of the container's resource requests"

                                        for resourceName := range container.Resources.Requests {
                                                if resourceName == allocatedResource.Name {
                                                        found = true
                                                        break
                                                }
                                        }
                                }
                                if !found {
                                        allErrors = append(allErrors, field.Invalid(fldPath.Index(i).Child("allocatedResourcesStatus").Index(j).Child("name"), allocatedResource.Name, errorStr))
                                }
                        }

                        uniqueResources := sets.New[core.ResourceID]()
                        // check resource IDs are unique
                        for k, r := range allocatedResource.Resources {

                                var supportedResourceHealthValues = sets.New(
                                        core.ResourceHealthStatusHealthy,
                                        core.ResourceHealthStatusUnhealthy,
                                        core.ResourceHealthStatusUnknown)

                                if !supportedResourceHealthValues.Has(r.Health) {
                                        allErrors = append(allErrors, field.NotSupported(fldPath.Index(i).Child("allocatedResourcesStatus").Index(j).Child("resources").Index(k).Child("health"), r.Health, sets.List(supportedResourceHealthValues)))
                                }

                                if uniqueResources.Has(r.ResourceID) {
                                        allErrors = append(allErrors, field.Duplicate(fldPath.Index(i).Child("allocatedResourcesStatus").Index(j).Child("resources").Index(k).Child("resourceID"), r.ResourceID))
                                } else {
                                        uniqueResources.Insert(r.ResourceID)
                                }
                        }
                }
        }

        return allErrors
}

func validateLinuxContainerUser(linuxContainerUser *core.LinuxContainerUser, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}
        if linuxContainerUser == nil {
                return allErrors
        }
        for _, msg := range validation.IsValidUserID(linuxContainerUser.UID) {
                allErrors = append(allErrors, field.Invalid(fldPath.Child("uid"), linuxContainerUser.UID, msg))
        }

        for _, msg := range validation.IsValidGroupID(linuxContainerUser.GID) {
                allErrors = append(allErrors, field.Invalid(fldPath.Child("gid"), linuxContainerUser.GID, msg))
        }
        for g, gid := range linuxContainerUser.SupplementalGroups {
                for _, msg := range validation.IsValidGroupID(gid) {
                        allErrors = append(allErrors, field.Invalid(fldPath.Child("supplementalGroups").Index(g), gid, msg))
                }
        }
        return allErrors
}

func validateImageVolumeSource(imageVolume *core.ImageVolumeSource, fldPath *field.Path, opts PodValidationOptions) field.ErrorList {
        allErrs := field.ErrorList{}
        if opts.ResourceIsPod && len(imageVolume.Reference) == 0 {
                allErrs = append(allErrs, field.Required(fldPath.Child("reference"), ""))
        }
        allErrs = append(allErrs, validatePullPolicy(imageVolume.PullPolicy, fldPath.Child("pullPolicy"))...)
        return allErrs
}

// isRestartableInitContainer returns true if the container has ContainerRestartPolicyAlways.
func isRestartableInitContainer(initContainer *core.Container) bool {
        if initContainer == nil || initContainer.RestartPolicy == nil {
                return false
        }
        return *initContainer.RestartPolicy == core.ContainerRestartPolicyAlways
}

// IsValidIPForLegacyField is a wrapper around validation.IsValidIPForLegacyField that
// handles setting strictValidation correctly. This is only for fields that use legacy IP
// address validation; use validation.IsValidIP for new fields.
func IsValidIPForLegacyField(fldPath *field.Path, value string, validOldIPs []string) field.ErrorList {
        return validation.IsValidIPForLegacyField(fldPath, value, utilfeature.DefaultFeatureGate.Enabled(features.StrictIPCIDRValidation), validOldIPs)
}

// IsValidCIDRForLegacyField is a wrapper around validation.IsValidCIDRForLegacyField that
// handles setting strictValidation correctly. This is only for fields that use legacy CIDR
// value validation; use validation.IsValidCIDR for new fields.
func IsValidCIDRForLegacyField(fldPath *field.Path, value string, validOldCIDRs []string) field.ErrorList {
        return validation.IsValidCIDRForLegacyField(fldPath, value, utilfeature.DefaultFeatureGate.Enabled(features.StrictIPCIDRValidation), validOldCIDRs)
}

func validateNodeSwapStatus(nodeSwapStatus *core.NodeSwapStatus, fldPath *field.Path) field.ErrorList {
        allErrors := field.ErrorList{}

        if nodeSwapStatus == nil {
                return allErrors
        }

        if nodeSwapStatus.Capacity != nil {
                capacityFld := fldPath.Child("capacity")

                errs := ValidatePositiveField(*nodeSwapStatus.Capacity, capacityFld)
                if len(errs) > 0 {
                        allErrors = append(allErrors, errs...)
                }
        }

        return allErrors
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package core

import (
        v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        types "k8s.io/apimachinery/pkg/types"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AWSElasticBlockStoreVolumeSource) DeepCopyInto(out *AWSElasticBlockStoreVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AWSElasticBlockStoreVolumeSource.
func (in *AWSElasticBlockStoreVolumeSource) DeepCopy() *AWSElasticBlockStoreVolumeSource {
        if in == nil {
                return nil
        }
        out := new(AWSElasticBlockStoreVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Affinity) DeepCopyInto(out *Affinity) {
        *out = *in
        if in.NodeAffinity != nil {
                in, out := &in.NodeAffinity, &out.NodeAffinity
                *out = new(NodeAffinity)
                (*in).DeepCopyInto(*out)
        }
        if in.PodAffinity != nil {
                in, out := &in.PodAffinity, &out.PodAffinity
                *out = new(PodAffinity)
                (*in).DeepCopyInto(*out)
        }
        if in.PodAntiAffinity != nil {
                in, out := &in.PodAntiAffinity, &out.PodAntiAffinity
                *out = new(PodAntiAffinity)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Affinity.
func (in *Affinity) DeepCopy() *Affinity {
        if in == nil {
                return nil
        }
        out := new(Affinity)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AppArmorProfile) DeepCopyInto(out *AppArmorProfile) {
        *out = *in
        if in.LocalhostProfile != nil {
                in, out := &in.LocalhostProfile, &out.LocalhostProfile
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AppArmorProfile.
func (in *AppArmorProfile) DeepCopy() *AppArmorProfile {
        if in == nil {
                return nil
        }
        out := new(AppArmorProfile)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AttachedVolume) DeepCopyInto(out *AttachedVolume) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AttachedVolume.
func (in *AttachedVolume) DeepCopy() *AttachedVolume {
        if in == nil {
                return nil
        }
        out := new(AttachedVolume)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AvoidPods) DeepCopyInto(out *AvoidPods) {
        *out = *in
        if in.PreferAvoidPods != nil {
                in, out := &in.PreferAvoidPods, &out.PreferAvoidPods
                *out = make([]PreferAvoidPodsEntry, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AvoidPods.
func (in *AvoidPods) DeepCopy() *AvoidPods {
        if in == nil {
                return nil
        }
        out := new(AvoidPods)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AzureDiskVolumeSource) DeepCopyInto(out *AzureDiskVolumeSource) {
        *out = *in
        if in.CachingMode != nil {
                in, out := &in.CachingMode, &out.CachingMode
                *out = new(AzureDataDiskCachingMode)
                **out = **in
        }
        if in.FSType != nil {
                in, out := &in.FSType, &out.FSType
                *out = new(string)
                **out = **in
        }
        if in.ReadOnly != nil {
                in, out := &in.ReadOnly, &out.ReadOnly
                *out = new(bool)
                **out = **in
        }
        if in.Kind != nil {
                in, out := &in.Kind, &out.Kind
                *out = new(AzureDataDiskKind)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AzureDiskVolumeSource.
func (in *AzureDiskVolumeSource) DeepCopy() *AzureDiskVolumeSource {
        if in == nil {
                return nil
        }
        out := new(AzureDiskVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AzureFilePersistentVolumeSource) DeepCopyInto(out *AzureFilePersistentVolumeSource) {
        *out = *in
        if in.SecretNamespace != nil {
                in, out := &in.SecretNamespace, &out.SecretNamespace
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AzureFilePersistentVolumeSource.
func (in *AzureFilePersistentVolumeSource) DeepCopy() *AzureFilePersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(AzureFilePersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *AzureFileVolumeSource) DeepCopyInto(out *AzureFileVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AzureFileVolumeSource.
func (in *AzureFileVolumeSource) DeepCopy() *AzureFileVolumeSource {
        if in == nil {
                return nil
        }
        out := new(AzureFileVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Binding) DeepCopyInto(out *Binding) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        out.Target = in.Target
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Binding.
func (in *Binding) DeepCopy() *Binding {
        if in == nil {
                return nil
        }
        out := new(Binding)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Binding) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CSIPersistentVolumeSource) DeepCopyInto(out *CSIPersistentVolumeSource) {
        *out = *in
        if in.VolumeAttributes != nil {
                in, out := &in.VolumeAttributes, &out.VolumeAttributes
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.ControllerPublishSecretRef != nil {
                in, out := &in.ControllerPublishSecretRef, &out.ControllerPublishSecretRef
                *out = new(SecretReference)
                **out = **in
        }
        if in.NodeStageSecretRef != nil {
                in, out := &in.NodeStageSecretRef, &out.NodeStageSecretRef
                *out = new(SecretReference)
                **out = **in
        }
        if in.NodePublishSecretRef != nil {
                in, out := &in.NodePublishSecretRef, &out.NodePublishSecretRef
                *out = new(SecretReference)
                **out = **in
        }
        if in.ControllerExpandSecretRef != nil {
                in, out := &in.ControllerExpandSecretRef, &out.ControllerExpandSecretRef
                *out = new(SecretReference)
                **out = **in
        }
        if in.NodeExpandSecretRef != nil {
                in, out := &in.NodeExpandSecretRef, &out.NodeExpandSecretRef
                *out = new(SecretReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CSIPersistentVolumeSource.
func (in *CSIPersistentVolumeSource) DeepCopy() *CSIPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(CSIPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CSIVolumeSource) DeepCopyInto(out *CSIVolumeSource) {
        *out = *in
        if in.ReadOnly != nil {
                in, out := &in.ReadOnly, &out.ReadOnly
                *out = new(bool)
                **out = **in
        }
        if in.FSType != nil {
                in, out := &in.FSType, &out.FSType
                *out = new(string)
                **out = **in
        }
        if in.VolumeAttributes != nil {
                in, out := &in.VolumeAttributes, &out.VolumeAttributes
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.NodePublishSecretRef != nil {
                in, out := &in.NodePublishSecretRef, &out.NodePublishSecretRef
                *out = new(LocalObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CSIVolumeSource.
func (in *CSIVolumeSource) DeepCopy() *CSIVolumeSource {
        if in == nil {
                return nil
        }
        out := new(CSIVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Capabilities) DeepCopyInto(out *Capabilities) {
        *out = *in
        if in.Add != nil {
                in, out := &in.Add, &out.Add
                *out = make([]Capability, len(*in))
                copy(*out, *in)
        }
        if in.Drop != nil {
                in, out := &in.Drop, &out.Drop
                *out = make([]Capability, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Capabilities.
func (in *Capabilities) DeepCopy() *Capabilities {
        if in == nil {
                return nil
        }
        out := new(Capabilities)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CephFSPersistentVolumeSource) DeepCopyInto(out *CephFSPersistentVolumeSource) {
        *out = *in
        if in.Monitors != nil {
                in, out := &in.Monitors, &out.Monitors
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(SecretReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CephFSPersistentVolumeSource.
func (in *CephFSPersistentVolumeSource) DeepCopy() *CephFSPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(CephFSPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CephFSVolumeSource) DeepCopyInto(out *CephFSVolumeSource) {
        *out = *in
        if in.Monitors != nil {
                in, out := &in.Monitors, &out.Monitors
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(LocalObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CephFSVolumeSource.
func (in *CephFSVolumeSource) DeepCopy() *CephFSVolumeSource {
        if in == nil {
                return nil
        }
        out := new(CephFSVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CinderPersistentVolumeSource) DeepCopyInto(out *CinderPersistentVolumeSource) {
        *out = *in
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(SecretReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CinderPersistentVolumeSource.
func (in *CinderPersistentVolumeSource) DeepCopy() *CinderPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(CinderPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CinderVolumeSource) DeepCopyInto(out *CinderVolumeSource) {
        *out = *in
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(LocalObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CinderVolumeSource.
func (in *CinderVolumeSource) DeepCopy() *CinderVolumeSource {
        if in == nil {
                return nil
        }
        out := new(CinderVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ClientIPConfig) DeepCopyInto(out *ClientIPConfig) {
        *out = *in
        if in.TimeoutSeconds != nil {
                in, out := &in.TimeoutSeconds, &out.TimeoutSeconds
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClientIPConfig.
func (in *ClientIPConfig) DeepCopy() *ClientIPConfig {
        if in == nil {
                return nil
        }
        out := new(ClientIPConfig)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ClusterTrustBundleProjection) DeepCopyInto(out *ClusterTrustBundleProjection) {
        *out = *in
        if in.Name != nil {
                in, out := &in.Name, &out.Name
                *out = new(string)
                **out = **in
        }
        if in.SignerName != nil {
                in, out := &in.SignerName, &out.SignerName
                *out = new(string)
                **out = **in
        }
        if in.LabelSelector != nil {
                in, out := &in.LabelSelector, &out.LabelSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterTrustBundleProjection.
func (in *ClusterTrustBundleProjection) DeepCopy() *ClusterTrustBundleProjection {
        if in == nil {
                return nil
        }
        out := new(ClusterTrustBundleProjection)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ComponentCondition) DeepCopyInto(out *ComponentCondition) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComponentCondition.
func (in *ComponentCondition) DeepCopy() *ComponentCondition {
        if in == nil {
                return nil
        }
        out := new(ComponentCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ComponentStatus) DeepCopyInto(out *ComponentStatus) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]ComponentCondition, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComponentStatus.
func (in *ComponentStatus) DeepCopy() *ComponentStatus {
        if in == nil {
                return nil
        }
        out := new(ComponentStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ComponentStatus) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ComponentStatusList) DeepCopyInto(out *ComponentStatusList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ComponentStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ComponentStatusList.
func (in *ComponentStatusList) DeepCopy() *ComponentStatusList {
        if in == nil {
                return nil
        }
        out := new(ComponentStatusList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ComponentStatusList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ConfigMap) DeepCopyInto(out *ConfigMap) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Immutable != nil {
                in, out := &in.Immutable, &out.Immutable
                *out = new(bool)
                **out = **in
        }
        if in.Data != nil {
                in, out := &in.Data, &out.Data
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.BinaryData != nil {
                in, out := &in.BinaryData, &out.BinaryData
                *out = make(map[string][]byte, len(*in))
                for key, val := range *in {
                        var outVal []byte
                        if val == nil {
                                (*out)[key] = nil
                        } else {
                                in, out := &val, &outVal
                                *out = make([]byte, len(*in))
                                copy(*out, *in)
                        }
                        (*out)[key] = outVal
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConfigMap.
func (in *ConfigMap) DeepCopy() *ConfigMap {
        if in == nil {
                return nil
        }
        out := new(ConfigMap)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ConfigMap) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ConfigMapEnvSource) DeepCopyInto(out *ConfigMapEnvSource) {
        *out = *in
        out.LocalObjectReference = in.LocalObjectReference
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConfigMapEnvSource.
func (in *ConfigMapEnvSource) DeepCopy() *ConfigMapEnvSource {
        if in == nil {
                return nil
        }
        out := new(ConfigMapEnvSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ConfigMapKeySelector) DeepCopyInto(out *ConfigMapKeySelector) {
        *out = *in
        out.LocalObjectReference = in.LocalObjectReference
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConfigMapKeySelector.
func (in *ConfigMapKeySelector) DeepCopy() *ConfigMapKeySelector {
        if in == nil {
                return nil
        }
        out := new(ConfigMapKeySelector)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ConfigMapList) DeepCopyInto(out *ConfigMapList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ConfigMap, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConfigMapList.
func (in *ConfigMapList) DeepCopy() *ConfigMapList {
        if in == nil {
                return nil
        }
        out := new(ConfigMapList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ConfigMapList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ConfigMapNodeConfigSource) DeepCopyInto(out *ConfigMapNodeConfigSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConfigMapNodeConfigSource.
func (in *ConfigMapNodeConfigSource) DeepCopy() *ConfigMapNodeConfigSource {
        if in == nil {
                return nil
        }
        out := new(ConfigMapNodeConfigSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ConfigMapProjection) DeepCopyInto(out *ConfigMapProjection) {
        *out = *in
        out.LocalObjectReference = in.LocalObjectReference
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]KeyToPath, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConfigMapProjection.
func (in *ConfigMapProjection) DeepCopy() *ConfigMapProjection {
        if in == nil {
                return nil
        }
        out := new(ConfigMapProjection)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ConfigMapVolumeSource) DeepCopyInto(out *ConfigMapVolumeSource) {
        *out = *in
        out.LocalObjectReference = in.LocalObjectReference
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]KeyToPath, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.DefaultMode != nil {
                in, out := &in.DefaultMode, &out.DefaultMode
                *out = new(int32)
                **out = **in
        }
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConfigMapVolumeSource.
func (in *ConfigMapVolumeSource) DeepCopy() *ConfigMapVolumeSource {
        if in == nil {
                return nil
        }
        out := new(ConfigMapVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Container) DeepCopyInto(out *Container) {
        *out = *in
        if in.Command != nil {
                in, out := &in.Command, &out.Command
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Args != nil {
                in, out := &in.Args, &out.Args
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Ports != nil {
                in, out := &in.Ports, &out.Ports
                *out = make([]ContainerPort, len(*in))
                copy(*out, *in)
        }
        if in.EnvFrom != nil {
                in, out := &in.EnvFrom, &out.EnvFrom
                *out = make([]EnvFromSource, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Env != nil {
                in, out := &in.Env, &out.Env
                *out = make([]EnvVar, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        in.Resources.DeepCopyInto(&out.Resources)
        if in.ResizePolicy != nil {
                in, out := &in.ResizePolicy, &out.ResizePolicy
                *out = make([]ContainerResizePolicy, len(*in))
                copy(*out, *in)
        }
        if in.RestartPolicy != nil {
                in, out := &in.RestartPolicy, &out.RestartPolicy
                *out = new(ContainerRestartPolicy)
                **out = **in
        }
        if in.RestartPolicyRules != nil {
                in, out := &in.RestartPolicyRules, &out.RestartPolicyRules
                *out = make([]ContainerRestartRule, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.VolumeMounts != nil {
                in, out := &in.VolumeMounts, &out.VolumeMounts
                *out = make([]VolumeMount, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.VolumeDevices != nil {
                in, out := &in.VolumeDevices, &out.VolumeDevices
                *out = make([]VolumeDevice, len(*in))
                copy(*out, *in)
        }
        if in.LivenessProbe != nil {
                in, out := &in.LivenessProbe, &out.LivenessProbe
                *out = new(Probe)
                (*in).DeepCopyInto(*out)
        }
        if in.ReadinessProbe != nil {
                in, out := &in.ReadinessProbe, &out.ReadinessProbe
                *out = new(Probe)
                (*in).DeepCopyInto(*out)
        }
        if in.StartupProbe != nil {
                in, out := &in.StartupProbe, &out.StartupProbe
                *out = new(Probe)
                (*in).DeepCopyInto(*out)
        }
        if in.Lifecycle != nil {
                in, out := &in.Lifecycle, &out.Lifecycle
                *out = new(Lifecycle)
                (*in).DeepCopyInto(*out)
        }
        if in.SecurityContext != nil {
                in, out := &in.SecurityContext, &out.SecurityContext
                *out = new(SecurityContext)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Container.
func (in *Container) DeepCopy() *Container {
        if in == nil {
                return nil
        }
        out := new(Container)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerExtendedResourceRequest) DeepCopyInto(out *ContainerExtendedResourceRequest) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerExtendedResourceRequest.
func (in *ContainerExtendedResourceRequest) DeepCopy() *ContainerExtendedResourceRequest {
        if in == nil {
                return nil
        }
        out := new(ContainerExtendedResourceRequest)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerImage) DeepCopyInto(out *ContainerImage) {
        *out = *in
        if in.Names != nil {
                in, out := &in.Names, &out.Names
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerImage.
func (in *ContainerImage) DeepCopy() *ContainerImage {
        if in == nil {
                return nil
        }
        out := new(ContainerImage)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerPort) DeepCopyInto(out *ContainerPort) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerPort.
func (in *ContainerPort) DeepCopy() *ContainerPort {
        if in == nil {
                return nil
        }
        out := new(ContainerPort)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerResizePolicy) DeepCopyInto(out *ContainerResizePolicy) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerResizePolicy.
func (in *ContainerResizePolicy) DeepCopy() *ContainerResizePolicy {
        if in == nil {
                return nil
        }
        out := new(ContainerResizePolicy)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerRestartRule) DeepCopyInto(out *ContainerRestartRule) {
        *out = *in
        if in.ExitCodes != nil {
                in, out := &in.ExitCodes, &out.ExitCodes
                *out = new(ContainerRestartRuleOnExitCodes)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerRestartRule.
func (in *ContainerRestartRule) DeepCopy() *ContainerRestartRule {
        if in == nil {
                return nil
        }
        out := new(ContainerRestartRule)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerRestartRuleOnExitCodes) DeepCopyInto(out *ContainerRestartRuleOnExitCodes) {
        *out = *in
        if in.Values != nil {
                in, out := &in.Values, &out.Values
                *out = make([]int32, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerRestartRuleOnExitCodes.
func (in *ContainerRestartRuleOnExitCodes) DeepCopy() *ContainerRestartRuleOnExitCodes {
        if in == nil {
                return nil
        }
        out := new(ContainerRestartRuleOnExitCodes)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerState) DeepCopyInto(out *ContainerState) {
        *out = *in
        if in.Waiting != nil {
                in, out := &in.Waiting, &out.Waiting
                *out = new(ContainerStateWaiting)
                **out = **in
        }
        if in.Running != nil {
                in, out := &in.Running, &out.Running
                *out = new(ContainerStateRunning)
                (*in).DeepCopyInto(*out)
        }
        if in.Terminated != nil {
                in, out := &in.Terminated, &out.Terminated
                *out = new(ContainerStateTerminated)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerState.
func (in *ContainerState) DeepCopy() *ContainerState {
        if in == nil {
                return nil
        }
        out := new(ContainerState)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerStateRunning) DeepCopyInto(out *ContainerStateRunning) {
        *out = *in
        in.StartedAt.DeepCopyInto(&out.StartedAt)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerStateRunning.
func (in *ContainerStateRunning) DeepCopy() *ContainerStateRunning {
        if in == nil {
                return nil
        }
        out := new(ContainerStateRunning)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerStateTerminated) DeepCopyInto(out *ContainerStateTerminated) {
        *out = *in
        in.StartedAt.DeepCopyInto(&out.StartedAt)
        in.FinishedAt.DeepCopyInto(&out.FinishedAt)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerStateTerminated.
func (in *ContainerStateTerminated) DeepCopy() *ContainerStateTerminated {
        if in == nil {
                return nil
        }
        out := new(ContainerStateTerminated)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerStateWaiting) DeepCopyInto(out *ContainerStateWaiting) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerStateWaiting.
func (in *ContainerStateWaiting) DeepCopy() *ContainerStateWaiting {
        if in == nil {
                return nil
        }
        out := new(ContainerStateWaiting)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerStatus) DeepCopyInto(out *ContainerStatus) {
        *out = *in
        in.State.DeepCopyInto(&out.State)
        in.LastTerminationState.DeepCopyInto(&out.LastTerminationState)
        if in.Started != nil {
                in, out := &in.Started, &out.Started
                *out = new(bool)
                **out = **in
        }
        if in.AllocatedResources != nil {
                in, out := &in.AllocatedResources, &out.AllocatedResources
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Resources != nil {
                in, out := &in.Resources, &out.Resources
                *out = new(ResourceRequirements)
                (*in).DeepCopyInto(*out)
        }
        if in.VolumeMounts != nil {
                in, out := &in.VolumeMounts, &out.VolumeMounts
                *out = make([]VolumeMountStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.User != nil {
                in, out := &in.User, &out.User
                *out = new(ContainerUser)
                (*in).DeepCopyInto(*out)
        }
        if in.AllocatedResourcesStatus != nil {
                in, out := &in.AllocatedResourcesStatus, &out.AllocatedResourcesStatus
                *out = make([]ResourceStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.StopSignal != nil {
                in, out := &in.StopSignal, &out.StopSignal
                *out = new(Signal)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerStatus.
func (in *ContainerStatus) DeepCopy() *ContainerStatus {
        if in == nil {
                return nil
        }
        out := new(ContainerStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ContainerUser) DeepCopyInto(out *ContainerUser) {
        *out = *in
        if in.Linux != nil {
                in, out := &in.Linux, &out.Linux
                *out = new(LinuxContainerUser)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ContainerUser.
func (in *ContainerUser) DeepCopy() *ContainerUser {
        if in == nil {
                return nil
        }
        out := new(ContainerUser)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DaemonEndpoint) DeepCopyInto(out *DaemonEndpoint) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DaemonEndpoint.
func (in *DaemonEndpoint) DeepCopy() *DaemonEndpoint {
        if in == nil {
                return nil
        }
        out := new(DaemonEndpoint)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DownwardAPIProjection) DeepCopyInto(out *DownwardAPIProjection) {
        *out = *in
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]DownwardAPIVolumeFile, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DownwardAPIProjection.
func (in *DownwardAPIProjection) DeepCopy() *DownwardAPIProjection {
        if in == nil {
                return nil
        }
        out := new(DownwardAPIProjection)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DownwardAPIVolumeFile) DeepCopyInto(out *DownwardAPIVolumeFile) {
        *out = *in
        if in.FieldRef != nil {
                in, out := &in.FieldRef, &out.FieldRef
                *out = new(ObjectFieldSelector)
                **out = **in
        }
        if in.ResourceFieldRef != nil {
                in, out := &in.ResourceFieldRef, &out.ResourceFieldRef
                *out = new(ResourceFieldSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.Mode != nil {
                in, out := &in.Mode, &out.Mode
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DownwardAPIVolumeFile.
func (in *DownwardAPIVolumeFile) DeepCopy() *DownwardAPIVolumeFile {
        if in == nil {
                return nil
        }
        out := new(DownwardAPIVolumeFile)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *DownwardAPIVolumeSource) DeepCopyInto(out *DownwardAPIVolumeSource) {
        *out = *in
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]DownwardAPIVolumeFile, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.DefaultMode != nil {
                in, out := &in.DefaultMode, &out.DefaultMode
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DownwardAPIVolumeSource.
func (in *DownwardAPIVolumeSource) DeepCopy() *DownwardAPIVolumeSource {
        if in == nil {
                return nil
        }
        out := new(DownwardAPIVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EmptyDirVolumeSource) DeepCopyInto(out *EmptyDirVolumeSource) {
        *out = *in
        if in.SizeLimit != nil {
                in, out := &in.SizeLimit, &out.SizeLimit
                x := (*in).DeepCopy()
                *out = &x
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EmptyDirVolumeSource.
func (in *EmptyDirVolumeSource) DeepCopy() *EmptyDirVolumeSource {
        if in == nil {
                return nil
        }
        out := new(EmptyDirVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointAddress) DeepCopyInto(out *EndpointAddress) {
        *out = *in
        if in.NodeName != nil {
                in, out := &in.NodeName, &out.NodeName
                *out = new(string)
                **out = **in
        }
        if in.TargetRef != nil {
                in, out := &in.TargetRef, &out.TargetRef
                *out = new(ObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointAddress.
func (in *EndpointAddress) DeepCopy() *EndpointAddress {
        if in == nil {
                return nil
        }
        out := new(EndpointAddress)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointPort) DeepCopyInto(out *EndpointPort) {
        *out = *in
        if in.AppProtocol != nil {
                in, out := &in.AppProtocol, &out.AppProtocol
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointPort.
func (in *EndpointPort) DeepCopy() *EndpointPort {
        if in == nil {
                return nil
        }
        out := new(EndpointPort)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointSubset) DeepCopyInto(out *EndpointSubset) {
        *out = *in
        if in.Addresses != nil {
                in, out := &in.Addresses, &out.Addresses
                *out = make([]EndpointAddress, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.NotReadyAddresses != nil {
                in, out := &in.NotReadyAddresses, &out.NotReadyAddresses
                *out = make([]EndpointAddress, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Ports != nil {
                in, out := &in.Ports, &out.Ports
                *out = make([]EndpointPort, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointSubset.
func (in *EndpointSubset) DeepCopy() *EndpointSubset {
        if in == nil {
                return nil
        }
        out := new(EndpointSubset)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Endpoints) DeepCopyInto(out *Endpoints) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Subsets != nil {
                in, out := &in.Subsets, &out.Subsets
                *out = make([]EndpointSubset, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Endpoints.
func (in *Endpoints) DeepCopy() *Endpoints {
        if in == nil {
                return nil
        }
        out := new(Endpoints)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Endpoints) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointsList) DeepCopyInto(out *EndpointsList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Endpoints, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointsList.
func (in *EndpointsList) DeepCopy() *EndpointsList {
        if in == nil {
                return nil
        }
        out := new(EndpointsList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *EndpointsList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EnvFromSource) DeepCopyInto(out *EnvFromSource) {
        *out = *in
        if in.ConfigMapRef != nil {
                in, out := &in.ConfigMapRef, &out.ConfigMapRef
                *out = new(ConfigMapEnvSource)
                (*in).DeepCopyInto(*out)
        }
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(SecretEnvSource)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EnvFromSource.
func (in *EnvFromSource) DeepCopy() *EnvFromSource {
        if in == nil {
                return nil
        }
        out := new(EnvFromSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EnvVar) DeepCopyInto(out *EnvVar) {
        *out = *in
        if in.ValueFrom != nil {
                in, out := &in.ValueFrom, &out.ValueFrom
                *out = new(EnvVarSource)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EnvVar.
func (in *EnvVar) DeepCopy() *EnvVar {
        if in == nil {
                return nil
        }
        out := new(EnvVar)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EnvVarSource) DeepCopyInto(out *EnvVarSource) {
        *out = *in
        if in.FieldRef != nil {
                in, out := &in.FieldRef, &out.FieldRef
                *out = new(ObjectFieldSelector)
                **out = **in
        }
        if in.ResourceFieldRef != nil {
                in, out := &in.ResourceFieldRef, &out.ResourceFieldRef
                *out = new(ResourceFieldSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.ConfigMapKeyRef != nil {
                in, out := &in.ConfigMapKeyRef, &out.ConfigMapKeyRef
                *out = new(ConfigMapKeySelector)
                (*in).DeepCopyInto(*out)
        }
        if in.SecretKeyRef != nil {
                in, out := &in.SecretKeyRef, &out.SecretKeyRef
                *out = new(SecretKeySelector)
                (*in).DeepCopyInto(*out)
        }
        if in.FileKeyRef != nil {
                in, out := &in.FileKeyRef, &out.FileKeyRef
                *out = new(FileKeySelector)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EnvVarSource.
func (in *EnvVarSource) DeepCopy() *EnvVarSource {
        if in == nil {
                return nil
        }
        out := new(EnvVarSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EphemeralContainer) DeepCopyInto(out *EphemeralContainer) {
        *out = *in
        in.EphemeralContainerCommon.DeepCopyInto(&out.EphemeralContainerCommon)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EphemeralContainer.
func (in *EphemeralContainer) DeepCopy() *EphemeralContainer {
        if in == nil {
                return nil
        }
        out := new(EphemeralContainer)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EphemeralContainerCommon) DeepCopyInto(out *EphemeralContainerCommon) {
        *out = *in
        if in.Command != nil {
                in, out := &in.Command, &out.Command
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Args != nil {
                in, out := &in.Args, &out.Args
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Ports != nil {
                in, out := &in.Ports, &out.Ports
                *out = make([]ContainerPort, len(*in))
                copy(*out, *in)
        }
        if in.EnvFrom != nil {
                in, out := &in.EnvFrom, &out.EnvFrom
                *out = make([]EnvFromSource, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Env != nil {
                in, out := &in.Env, &out.Env
                *out = make([]EnvVar, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        in.Resources.DeepCopyInto(&out.Resources)
        if in.ResizePolicy != nil {
                in, out := &in.ResizePolicy, &out.ResizePolicy
                *out = make([]ContainerResizePolicy, len(*in))
                copy(*out, *in)
        }
        if in.RestartPolicy != nil {
                in, out := &in.RestartPolicy, &out.RestartPolicy
                *out = new(ContainerRestartPolicy)
                **out = **in
        }
        if in.RestartPolicyRules != nil {
                in, out := &in.RestartPolicyRules, &out.RestartPolicyRules
                *out = make([]ContainerRestartRule, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.VolumeMounts != nil {
                in, out := &in.VolumeMounts, &out.VolumeMounts
                *out = make([]VolumeMount, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.VolumeDevices != nil {
                in, out := &in.VolumeDevices, &out.VolumeDevices
                *out = make([]VolumeDevice, len(*in))
                copy(*out, *in)
        }
        if in.LivenessProbe != nil {
                in, out := &in.LivenessProbe, &out.LivenessProbe
                *out = new(Probe)
                (*in).DeepCopyInto(*out)
        }
        if in.ReadinessProbe != nil {
                in, out := &in.ReadinessProbe, &out.ReadinessProbe
                *out = new(Probe)
                (*in).DeepCopyInto(*out)
        }
        if in.StartupProbe != nil {
                in, out := &in.StartupProbe, &out.StartupProbe
                *out = new(Probe)
                (*in).DeepCopyInto(*out)
        }
        if in.Lifecycle != nil {
                in, out := &in.Lifecycle, &out.Lifecycle
                *out = new(Lifecycle)
                (*in).DeepCopyInto(*out)
        }
        if in.SecurityContext != nil {
                in, out := &in.SecurityContext, &out.SecurityContext
                *out = new(SecurityContext)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EphemeralContainerCommon.
func (in *EphemeralContainerCommon) DeepCopy() *EphemeralContainerCommon {
        if in == nil {
                return nil
        }
        out := new(EphemeralContainerCommon)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EphemeralVolumeSource) DeepCopyInto(out *EphemeralVolumeSource) {
        *out = *in
        if in.VolumeClaimTemplate != nil {
                in, out := &in.VolumeClaimTemplate, &out.VolumeClaimTemplate
                *out = new(PersistentVolumeClaimTemplate)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EphemeralVolumeSource.
func (in *EphemeralVolumeSource) DeepCopy() *EphemeralVolumeSource {
        if in == nil {
                return nil
        }
        out := new(EphemeralVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Event) DeepCopyInto(out *Event) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        out.InvolvedObject = in.InvolvedObject
        out.Source = in.Source
        in.FirstTimestamp.DeepCopyInto(&out.FirstTimestamp)
        in.LastTimestamp.DeepCopyInto(&out.LastTimestamp)
        in.EventTime.DeepCopyInto(&out.EventTime)
        if in.Series != nil {
                in, out := &in.Series, &out.Series
                *out = new(EventSeries)
                (*in).DeepCopyInto(*out)
        }
        if in.Related != nil {
                in, out := &in.Related, &out.Related
                *out = new(ObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Event.
func (in *Event) DeepCopy() *Event {
        if in == nil {
                return nil
        }
        out := new(Event)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Event) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EventList) DeepCopyInto(out *EventList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Event, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EventList.
func (in *EventList) DeepCopy() *EventList {
        if in == nil {
                return nil
        }
        out := new(EventList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *EventList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EventSeries) DeepCopyInto(out *EventSeries) {
        *out = *in
        in.LastObservedTime.DeepCopyInto(&out.LastObservedTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EventSeries.
func (in *EventSeries) DeepCopy() *EventSeries {
        if in == nil {
                return nil
        }
        out := new(EventSeries)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EventSource) DeepCopyInto(out *EventSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EventSource.
func (in *EventSource) DeepCopy() *EventSource {
        if in == nil {
                return nil
        }
        out := new(EventSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ExecAction) DeepCopyInto(out *ExecAction) {
        *out = *in
        if in.Command != nil {
                in, out := &in.Command, &out.Command
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExecAction.
func (in *ExecAction) DeepCopy() *ExecAction {
        if in == nil {
                return nil
        }
        out := new(ExecAction)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *FCVolumeSource) DeepCopyInto(out *FCVolumeSource) {
        *out = *in
        if in.TargetWWNs != nil {
                in, out := &in.TargetWWNs, &out.TargetWWNs
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Lun != nil {
                in, out := &in.Lun, &out.Lun
                *out = new(int32)
                **out = **in
        }
        if in.WWIDs != nil {
                in, out := &in.WWIDs, &out.WWIDs
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FCVolumeSource.
func (in *FCVolumeSource) DeepCopy() *FCVolumeSource {
        if in == nil {
                return nil
        }
        out := new(FCVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *FileKeySelector) DeepCopyInto(out *FileKeySelector) {
        *out = *in
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FileKeySelector.
func (in *FileKeySelector) DeepCopy() *FileKeySelector {
        if in == nil {
                return nil
        }
        out := new(FileKeySelector)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *FlexPersistentVolumeSource) DeepCopyInto(out *FlexPersistentVolumeSource) {
        *out = *in
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(SecretReference)
                **out = **in
        }
        if in.Options != nil {
                in, out := &in.Options, &out.Options
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlexPersistentVolumeSource.
func (in *FlexPersistentVolumeSource) DeepCopy() *FlexPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(FlexPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *FlexVolumeSource) DeepCopyInto(out *FlexVolumeSource) {
        *out = *in
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(LocalObjectReference)
                **out = **in
        }
        if in.Options != nil {
                in, out := &in.Options, &out.Options
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlexVolumeSource.
func (in *FlexVolumeSource) DeepCopy() *FlexVolumeSource {
        if in == nil {
                return nil
        }
        out := new(FlexVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *FlockerVolumeSource) DeepCopyInto(out *FlockerVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlockerVolumeSource.
func (in *FlockerVolumeSource) DeepCopy() *FlockerVolumeSource {
        if in == nil {
                return nil
        }
        out := new(FlockerVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *GCEPersistentDiskVolumeSource) DeepCopyInto(out *GCEPersistentDiskVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GCEPersistentDiskVolumeSource.
func (in *GCEPersistentDiskVolumeSource) DeepCopy() *GCEPersistentDiskVolumeSource {
        if in == nil {
                return nil
        }
        out := new(GCEPersistentDiskVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *GRPCAction) DeepCopyInto(out *GRPCAction) {
        *out = *in
        if in.Service != nil {
                in, out := &in.Service, &out.Service
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GRPCAction.
func (in *GRPCAction) DeepCopy() *GRPCAction {
        if in == nil {
                return nil
        }
        out := new(GRPCAction)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *GitRepoVolumeSource) DeepCopyInto(out *GitRepoVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GitRepoVolumeSource.
func (in *GitRepoVolumeSource) DeepCopy() *GitRepoVolumeSource {
        if in == nil {
                return nil
        }
        out := new(GitRepoVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *GlusterfsPersistentVolumeSource) DeepCopyInto(out *GlusterfsPersistentVolumeSource) {
        *out = *in
        if in.EndpointsNamespace != nil {
                in, out := &in.EndpointsNamespace, &out.EndpointsNamespace
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlusterfsPersistentVolumeSource.
func (in *GlusterfsPersistentVolumeSource) DeepCopy() *GlusterfsPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(GlusterfsPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *GlusterfsVolumeSource) DeepCopyInto(out *GlusterfsVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GlusterfsVolumeSource.
func (in *GlusterfsVolumeSource) DeepCopy() *GlusterfsVolumeSource {
        if in == nil {
                return nil
        }
        out := new(GlusterfsVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HTTPGetAction) DeepCopyInto(out *HTTPGetAction) {
        *out = *in
        out.Port = in.Port
        if in.HTTPHeaders != nil {
                in, out := &in.HTTPHeaders, &out.HTTPHeaders
                *out = make([]HTTPHeader, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPGetAction.
func (in *HTTPGetAction) DeepCopy() *HTTPGetAction {
        if in == nil {
                return nil
        }
        out := new(HTTPGetAction)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HTTPHeader) DeepCopyInto(out *HTTPHeader) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPHeader.
func (in *HTTPHeader) DeepCopy() *HTTPHeader {
        if in == nil {
                return nil
        }
        out := new(HTTPHeader)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HostAlias) DeepCopyInto(out *HostAlias) {
        *out = *in
        if in.Hostnames != nil {
                in, out := &in.Hostnames, &out.Hostnames
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HostAlias.
func (in *HostAlias) DeepCopy() *HostAlias {
        if in == nil {
                return nil
        }
        out := new(HostAlias)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HostIP) DeepCopyInto(out *HostIP) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HostIP.
func (in *HostIP) DeepCopy() *HostIP {
        if in == nil {
                return nil
        }
        out := new(HostIP)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HostPathVolumeSource) DeepCopyInto(out *HostPathVolumeSource) {
        *out = *in
        if in.Type != nil {
                in, out := &in.Type, &out.Type
                *out = new(HostPathType)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HostPathVolumeSource.
func (in *HostPathVolumeSource) DeepCopy() *HostPathVolumeSource {
        if in == nil {
                return nil
        }
        out := new(HostPathVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ISCSIPersistentVolumeSource) DeepCopyInto(out *ISCSIPersistentVolumeSource) {
        *out = *in
        if in.Portals != nil {
                in, out := &in.Portals, &out.Portals
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(SecretReference)
                **out = **in
        }
        if in.InitiatorName != nil {
                in, out := &in.InitiatorName, &out.InitiatorName
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ISCSIPersistentVolumeSource.
func (in *ISCSIPersistentVolumeSource) DeepCopy() *ISCSIPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(ISCSIPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ISCSIVolumeSource) DeepCopyInto(out *ISCSIVolumeSource) {
        *out = *in
        if in.Portals != nil {
                in, out := &in.Portals, &out.Portals
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(LocalObjectReference)
                **out = **in
        }
        if in.InitiatorName != nil {
                in, out := &in.InitiatorName, &out.InitiatorName
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ISCSIVolumeSource.
func (in *ISCSIVolumeSource) DeepCopy() *ISCSIVolumeSource {
        if in == nil {
                return nil
        }
        out := new(ISCSIVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ImageVolumeSource) DeepCopyInto(out *ImageVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ImageVolumeSource.
func (in *ImageVolumeSource) DeepCopy() *ImageVolumeSource {
        if in == nil {
                return nil
        }
        out := new(ImageVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *KeyToPath) DeepCopyInto(out *KeyToPath) {
        *out = *in
        if in.Mode != nil {
                in, out := &in.Mode, &out.Mode
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KeyToPath.
func (in *KeyToPath) DeepCopy() *KeyToPath {
        if in == nil {
                return nil
        }
        out := new(KeyToPath)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Lifecycle) DeepCopyInto(out *Lifecycle) {
        *out = *in
        if in.PostStart != nil {
                in, out := &in.PostStart, &out.PostStart
                *out = new(LifecycleHandler)
                (*in).DeepCopyInto(*out)
        }
        if in.PreStop != nil {
                in, out := &in.PreStop, &out.PreStop
                *out = new(LifecycleHandler)
                (*in).DeepCopyInto(*out)
        }
        if in.StopSignal != nil {
                in, out := &in.StopSignal, &out.StopSignal
                *out = new(Signal)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Lifecycle.
func (in *Lifecycle) DeepCopy() *Lifecycle {
        if in == nil {
                return nil
        }
        out := new(Lifecycle)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LifecycleHandler) DeepCopyInto(out *LifecycleHandler) {
        *out = *in
        if in.Exec != nil {
                in, out := &in.Exec, &out.Exec
                *out = new(ExecAction)
                (*in).DeepCopyInto(*out)
        }
        if in.HTTPGet != nil {
                in, out := &in.HTTPGet, &out.HTTPGet
                *out = new(HTTPGetAction)
                (*in).DeepCopyInto(*out)
        }
        if in.TCPSocket != nil {
                in, out := &in.TCPSocket, &out.TCPSocket
                *out = new(TCPSocketAction)
                **out = **in
        }
        if in.Sleep != nil {
                in, out := &in.Sleep, &out.Sleep
                *out = new(SleepAction)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LifecycleHandler.
func (in *LifecycleHandler) DeepCopy() *LifecycleHandler {
        if in == nil {
                return nil
        }
        out := new(LifecycleHandler)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LimitRange) DeepCopyInto(out *LimitRange) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitRange.
func (in *LimitRange) DeepCopy() *LimitRange {
        if in == nil {
                return nil
        }
        out := new(LimitRange)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *LimitRange) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LimitRangeItem) DeepCopyInto(out *LimitRangeItem) {
        *out = *in
        if in.Max != nil {
                in, out := &in.Max, &out.Max
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Min != nil {
                in, out := &in.Min, &out.Min
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Default != nil {
                in, out := &in.Default, &out.Default
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.DefaultRequest != nil {
                in, out := &in.DefaultRequest, &out.DefaultRequest
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.MaxLimitRequestRatio != nil {
                in, out := &in.MaxLimitRequestRatio, &out.MaxLimitRequestRatio
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitRangeItem.
func (in *LimitRangeItem) DeepCopy() *LimitRangeItem {
        if in == nil {
                return nil
        }
        out := new(LimitRangeItem)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LimitRangeList) DeepCopyInto(out *LimitRangeList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]LimitRange, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitRangeList.
func (in *LimitRangeList) DeepCopy() *LimitRangeList {
        if in == nil {
                return nil
        }
        out := new(LimitRangeList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *LimitRangeList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LimitRangeSpec) DeepCopyInto(out *LimitRangeSpec) {
        *out = *in
        if in.Limits != nil {
                in, out := &in.Limits, &out.Limits
                *out = make([]LimitRangeItem, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitRangeSpec.
func (in *LimitRangeSpec) DeepCopy() *LimitRangeSpec {
        if in == nil {
                return nil
        }
        out := new(LimitRangeSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LinuxContainerUser) DeepCopyInto(out *LinuxContainerUser) {
        *out = *in
        if in.SupplementalGroups != nil {
                in, out := &in.SupplementalGroups, &out.SupplementalGroups
                *out = make([]int64, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LinuxContainerUser.
func (in *LinuxContainerUser) DeepCopy() *LinuxContainerUser {
        if in == nil {
                return nil
        }
        out := new(LinuxContainerUser)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *List) DeepCopyInto(out *List) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]runtime.Object, len(*in))
                for i := range *in {
                        if (*in)[i] != nil {
                                (*out)[i] = (*in)[i].DeepCopyObject()
                        }
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new List.
func (in *List) DeepCopy() *List {
        if in == nil {
                return nil
        }
        out := new(List)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *List) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LoadBalancerIngress) DeepCopyInto(out *LoadBalancerIngress) {
        *out = *in
        if in.IPMode != nil {
                in, out := &in.IPMode, &out.IPMode
                *out = new(LoadBalancerIPMode)
                **out = **in
        }
        if in.Ports != nil {
                in, out := &in.Ports, &out.Ports
                *out = make([]PortStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerIngress.
func (in *LoadBalancerIngress) DeepCopy() *LoadBalancerIngress {
        if in == nil {
                return nil
        }
        out := new(LoadBalancerIngress)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LoadBalancerStatus) DeepCopyInto(out *LoadBalancerStatus) {
        *out = *in
        if in.Ingress != nil {
                in, out := &in.Ingress, &out.Ingress
                *out = make([]LoadBalancerIngress, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerStatus.
func (in *LoadBalancerStatus) DeepCopy() *LoadBalancerStatus {
        if in == nil {
                return nil
        }
        out := new(LoadBalancerStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LocalObjectReference) DeepCopyInto(out *LocalObjectReference) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LocalObjectReference.
func (in *LocalObjectReference) DeepCopy() *LocalObjectReference {
        if in == nil {
                return nil
        }
        out := new(LocalObjectReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LocalVolumeSource) DeepCopyInto(out *LocalVolumeSource) {
        *out = *in
        if in.FSType != nil {
                in, out := &in.FSType, &out.FSType
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LocalVolumeSource.
func (in *LocalVolumeSource) DeepCopy() *LocalVolumeSource {
        if in == nil {
                return nil
        }
        out := new(LocalVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ModifyVolumeStatus) DeepCopyInto(out *ModifyVolumeStatus) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ModifyVolumeStatus.
func (in *ModifyVolumeStatus) DeepCopy() *ModifyVolumeStatus {
        if in == nil {
                return nil
        }
        out := new(ModifyVolumeStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NFSVolumeSource) DeepCopyInto(out *NFSVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NFSVolumeSource.
func (in *NFSVolumeSource) DeepCopy() *NFSVolumeSource {
        if in == nil {
                return nil
        }
        out := new(NFSVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Namespace) DeepCopyInto(out *Namespace) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Namespace.
func (in *Namespace) DeepCopy() *Namespace {
        if in == nil {
                return nil
        }
        out := new(Namespace)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Namespace) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NamespaceCondition) DeepCopyInto(out *NamespaceCondition) {
        *out = *in
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespaceCondition.
func (in *NamespaceCondition) DeepCopy() *NamespaceCondition {
        if in == nil {
                return nil
        }
        out := new(NamespaceCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NamespaceList) DeepCopyInto(out *NamespaceList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Namespace, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespaceList.
func (in *NamespaceList) DeepCopy() *NamespaceList {
        if in == nil {
                return nil
        }
        out := new(NamespaceList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *NamespaceList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NamespaceSpec) DeepCopyInto(out *NamespaceSpec) {
        *out = *in
        if in.Finalizers != nil {
                in, out := &in.Finalizers, &out.Finalizers
                *out = make([]FinalizerName, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespaceSpec.
func (in *NamespaceSpec) DeepCopy() *NamespaceSpec {
        if in == nil {
                return nil
        }
        out := new(NamespaceSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NamespaceStatus) DeepCopyInto(out *NamespaceStatus) {
        *out = *in
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]NamespaceCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NamespaceStatus.
func (in *NamespaceStatus) DeepCopy() *NamespaceStatus {
        if in == nil {
                return nil
        }
        out := new(NamespaceStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Node) DeepCopyInto(out *Node) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Node.
func (in *Node) DeepCopy() *Node {
        if in == nil {
                return nil
        }
        out := new(Node)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Node) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeAddress) DeepCopyInto(out *NodeAddress) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeAddress.
func (in *NodeAddress) DeepCopy() *NodeAddress {
        if in == nil {
                return nil
        }
        out := new(NodeAddress)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeAffinity) DeepCopyInto(out *NodeAffinity) {
        *out = *in
        if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
                in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
                *out = new(NodeSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
                in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
                *out = make([]PreferredSchedulingTerm, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeAffinity.
func (in *NodeAffinity) DeepCopy() *NodeAffinity {
        if in == nil {
                return nil
        }
        out := new(NodeAffinity)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeCondition) DeepCopyInto(out *NodeCondition) {
        *out = *in
        in.LastHeartbeatTime.DeepCopyInto(&out.LastHeartbeatTime)
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeCondition.
func (in *NodeCondition) DeepCopy() *NodeCondition {
        if in == nil {
                return nil
        }
        out := new(NodeCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeConfigSource) DeepCopyInto(out *NodeConfigSource) {
        *out = *in
        if in.ConfigMap != nil {
                in, out := &in.ConfigMap, &out.ConfigMap
                *out = new(ConfigMapNodeConfigSource)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeConfigSource.
func (in *NodeConfigSource) DeepCopy() *NodeConfigSource {
        if in == nil {
                return nil
        }
        out := new(NodeConfigSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeConfigStatus) DeepCopyInto(out *NodeConfigStatus) {
        *out = *in
        if in.Assigned != nil {
                in, out := &in.Assigned, &out.Assigned
                *out = new(NodeConfigSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Active != nil {
                in, out := &in.Active, &out.Active
                *out = new(NodeConfigSource)
                (*in).DeepCopyInto(*out)
        }
        if in.LastKnownGood != nil {
                in, out := &in.LastKnownGood, &out.LastKnownGood
                *out = new(NodeConfigSource)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeConfigStatus.
func (in *NodeConfigStatus) DeepCopy() *NodeConfigStatus {
        if in == nil {
                return nil
        }
        out := new(NodeConfigStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeDaemonEndpoints) DeepCopyInto(out *NodeDaemonEndpoints) {
        *out = *in
        out.KubeletEndpoint = in.KubeletEndpoint
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeDaemonEndpoints.
func (in *NodeDaemonEndpoints) DeepCopy() *NodeDaemonEndpoints {
        if in == nil {
                return nil
        }
        out := new(NodeDaemonEndpoints)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeFeatures) DeepCopyInto(out *NodeFeatures) {
        *out = *in
        if in.SupplementalGroupsPolicy != nil {
                in, out := &in.SupplementalGroupsPolicy, &out.SupplementalGroupsPolicy
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeFeatures.
func (in *NodeFeatures) DeepCopy() *NodeFeatures {
        if in == nil {
                return nil
        }
        out := new(NodeFeatures)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeList) DeepCopyInto(out *NodeList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Node, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeList.
func (in *NodeList) DeepCopy() *NodeList {
        if in == nil {
                return nil
        }
        out := new(NodeList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *NodeList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeProxyOptions) DeepCopyInto(out *NodeProxyOptions) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeProxyOptions.
func (in *NodeProxyOptions) DeepCopy() *NodeProxyOptions {
        if in == nil {
                return nil
        }
        out := new(NodeProxyOptions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *NodeProxyOptions) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeRuntimeHandler) DeepCopyInto(out *NodeRuntimeHandler) {
        *out = *in
        if in.Features != nil {
                in, out := &in.Features, &out.Features
                *out = new(NodeRuntimeHandlerFeatures)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeRuntimeHandler.
func (in *NodeRuntimeHandler) DeepCopy() *NodeRuntimeHandler {
        if in == nil {
                return nil
        }
        out := new(NodeRuntimeHandler)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeRuntimeHandlerFeatures) DeepCopyInto(out *NodeRuntimeHandlerFeatures) {
        *out = *in
        if in.RecursiveReadOnlyMounts != nil {
                in, out := &in.RecursiveReadOnlyMounts, &out.RecursiveReadOnlyMounts
                *out = new(bool)
                **out = **in
        }
        if in.UserNamespaces != nil {
                in, out := &in.UserNamespaces, &out.UserNamespaces
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeRuntimeHandlerFeatures.
func (in *NodeRuntimeHandlerFeatures) DeepCopy() *NodeRuntimeHandlerFeatures {
        if in == nil {
                return nil
        }
        out := new(NodeRuntimeHandlerFeatures)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeSelector) DeepCopyInto(out *NodeSelector) {
        *out = *in
        if in.NodeSelectorTerms != nil {
                in, out := &in.NodeSelectorTerms, &out.NodeSelectorTerms
                *out = make([]NodeSelectorTerm, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeSelector.
func (in *NodeSelector) DeepCopy() *NodeSelector {
        if in == nil {
                return nil
        }
        out := new(NodeSelector)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeSelectorRequirement) DeepCopyInto(out *NodeSelectorRequirement) {
        *out = *in
        if in.Values != nil {
                in, out := &in.Values, &out.Values
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeSelectorRequirement.
func (in *NodeSelectorRequirement) DeepCopy() *NodeSelectorRequirement {
        if in == nil {
                return nil
        }
        out := new(NodeSelectorRequirement)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeSelectorTerm) DeepCopyInto(out *NodeSelectorTerm) {
        *out = *in
        if in.MatchExpressions != nil {
                in, out := &in.MatchExpressions, &out.MatchExpressions
                *out = make([]NodeSelectorRequirement, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.MatchFields != nil {
                in, out := &in.MatchFields, &out.MatchFields
                *out = make([]NodeSelectorRequirement, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeSelectorTerm.
func (in *NodeSelectorTerm) DeepCopy() *NodeSelectorTerm {
        if in == nil {
                return nil
        }
        out := new(NodeSelectorTerm)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeSpec) DeepCopyInto(out *NodeSpec) {
        *out = *in
        if in.PodCIDRs != nil {
                in, out := &in.PodCIDRs, &out.PodCIDRs
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Taints != nil {
                in, out := &in.Taints, &out.Taints
                *out = make([]Taint, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.ConfigSource != nil {
                in, out := &in.ConfigSource, &out.ConfigSource
                *out = new(NodeConfigSource)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeSpec.
func (in *NodeSpec) DeepCopy() *NodeSpec {
        if in == nil {
                return nil
        }
        out := new(NodeSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeStatus) DeepCopyInto(out *NodeStatus) {
        *out = *in
        if in.Capacity != nil {
                in, out := &in.Capacity, &out.Capacity
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Allocatable != nil {
                in, out := &in.Allocatable, &out.Allocatable
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]NodeCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Addresses != nil {
                in, out := &in.Addresses, &out.Addresses
                *out = make([]NodeAddress, len(*in))
                copy(*out, *in)
        }
        out.DaemonEndpoints = in.DaemonEndpoints
        in.NodeInfo.DeepCopyInto(&out.NodeInfo)
        if in.Images != nil {
                in, out := &in.Images, &out.Images
                *out = make([]ContainerImage, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.VolumesInUse != nil {
                in, out := &in.VolumesInUse, &out.VolumesInUse
                *out = make([]UniqueVolumeName, len(*in))
                copy(*out, *in)
        }
        if in.VolumesAttached != nil {
                in, out := &in.VolumesAttached, &out.VolumesAttached
                *out = make([]AttachedVolume, len(*in))
                copy(*out, *in)
        }
        if in.Config != nil {
                in, out := &in.Config, &out.Config
                *out = new(NodeConfigStatus)
                (*in).DeepCopyInto(*out)
        }
        if in.RuntimeHandlers != nil {
                in, out := &in.RuntimeHandlers, &out.RuntimeHandlers
                *out = make([]NodeRuntimeHandler, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Features != nil {
                in, out := &in.Features, &out.Features
                *out = new(NodeFeatures)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeStatus.
func (in *NodeStatus) DeepCopy() *NodeStatus {
        if in == nil {
                return nil
        }
        out := new(NodeStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeSwapStatus) DeepCopyInto(out *NodeSwapStatus) {
        *out = *in
        if in.Capacity != nil {
                in, out := &in.Capacity, &out.Capacity
                *out = new(int64)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeSwapStatus.
func (in *NodeSwapStatus) DeepCopy() *NodeSwapStatus {
        if in == nil {
                return nil
        }
        out := new(NodeSwapStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NodeSystemInfo) DeepCopyInto(out *NodeSystemInfo) {
        *out = *in
        if in.Swap != nil {
                in, out := &in.Swap, &out.Swap
                *out = new(NodeSwapStatus)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NodeSystemInfo.
func (in *NodeSystemInfo) DeepCopy() *NodeSystemInfo {
        if in == nil {
                return nil
        }
        out := new(NodeSystemInfo)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ObjectFieldSelector) DeepCopyInto(out *ObjectFieldSelector) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectFieldSelector.
func (in *ObjectFieldSelector) DeepCopy() *ObjectFieldSelector {
        if in == nil {
                return nil
        }
        out := new(ObjectFieldSelector)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ObjectReference) DeepCopyInto(out *ObjectReference) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectReference.
func (in *ObjectReference) DeepCopy() *ObjectReference {
        if in == nil {
                return nil
        }
        out := new(ObjectReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ObjectReference) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolume) DeepCopyInto(out *PersistentVolume) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolume.
func (in *PersistentVolume) DeepCopy() *PersistentVolume {
        if in == nil {
                return nil
        }
        out := new(PersistentVolume)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PersistentVolume) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeClaim) DeepCopyInto(out *PersistentVolumeClaim) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeClaim.
func (in *PersistentVolumeClaim) DeepCopy() *PersistentVolumeClaim {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeClaim)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PersistentVolumeClaim) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeClaimCondition) DeepCopyInto(out *PersistentVolumeClaimCondition) {
        *out = *in
        in.LastProbeTime.DeepCopyInto(&out.LastProbeTime)
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeClaimCondition.
func (in *PersistentVolumeClaimCondition) DeepCopy() *PersistentVolumeClaimCondition {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeClaimCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeClaimList) DeepCopyInto(out *PersistentVolumeClaimList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]PersistentVolumeClaim, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeClaimList.
func (in *PersistentVolumeClaimList) DeepCopy() *PersistentVolumeClaimList {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeClaimList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PersistentVolumeClaimList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeClaimSpec) DeepCopyInto(out *PersistentVolumeClaimSpec) {
        *out = *in
        if in.AccessModes != nil {
                in, out := &in.AccessModes, &out.AccessModes
                *out = make([]PersistentVolumeAccessMode, len(*in))
                copy(*out, *in)
        }
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        in.Resources.DeepCopyInto(&out.Resources)
        if in.StorageClassName != nil {
                in, out := &in.StorageClassName, &out.StorageClassName
                *out = new(string)
                **out = **in
        }
        if in.VolumeMode != nil {
                in, out := &in.VolumeMode, &out.VolumeMode
                *out = new(PersistentVolumeMode)
                **out = **in
        }
        if in.DataSource != nil {
                in, out := &in.DataSource, &out.DataSource
                *out = new(TypedLocalObjectReference)
                (*in).DeepCopyInto(*out)
        }
        if in.DataSourceRef != nil {
                in, out := &in.DataSourceRef, &out.DataSourceRef
                *out = new(TypedObjectReference)
                (*in).DeepCopyInto(*out)
        }
        if in.VolumeAttributesClassName != nil {
                in, out := &in.VolumeAttributesClassName, &out.VolumeAttributesClassName
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeClaimSpec.
func (in *PersistentVolumeClaimSpec) DeepCopy() *PersistentVolumeClaimSpec {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeClaimSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeClaimStatus) DeepCopyInto(out *PersistentVolumeClaimStatus) {
        *out = *in
        if in.AccessModes != nil {
                in, out := &in.AccessModes, &out.AccessModes
                *out = make([]PersistentVolumeAccessMode, len(*in))
                copy(*out, *in)
        }
        if in.Capacity != nil {
                in, out := &in.Capacity, &out.Capacity
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]PersistentVolumeClaimCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.AllocatedResources != nil {
                in, out := &in.AllocatedResources, &out.AllocatedResources
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.AllocatedResourceStatuses != nil {
                in, out := &in.AllocatedResourceStatuses, &out.AllocatedResourceStatuses
                *out = make(map[ResourceName]ClaimResourceStatus, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.CurrentVolumeAttributesClassName != nil {
                in, out := &in.CurrentVolumeAttributesClassName, &out.CurrentVolumeAttributesClassName
                *out = new(string)
                **out = **in
        }
        if in.ModifyVolumeStatus != nil {
                in, out := &in.ModifyVolumeStatus, &out.ModifyVolumeStatus
                *out = new(ModifyVolumeStatus)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeClaimStatus.
func (in *PersistentVolumeClaimStatus) DeepCopy() *PersistentVolumeClaimStatus {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeClaimStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeClaimTemplate) DeepCopyInto(out *PersistentVolumeClaimTemplate) {
        *out = *in
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeClaimTemplate.
func (in *PersistentVolumeClaimTemplate) DeepCopy() *PersistentVolumeClaimTemplate {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeClaimTemplate)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeClaimVolumeSource) DeepCopyInto(out *PersistentVolumeClaimVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeClaimVolumeSource.
func (in *PersistentVolumeClaimVolumeSource) DeepCopy() *PersistentVolumeClaimVolumeSource {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeClaimVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeList) DeepCopyInto(out *PersistentVolumeList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]PersistentVolume, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeList.
func (in *PersistentVolumeList) DeepCopy() *PersistentVolumeList {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PersistentVolumeList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeSource) DeepCopyInto(out *PersistentVolumeSource) {
        *out = *in
        if in.GCEPersistentDisk != nil {
                in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk
                *out = new(GCEPersistentDiskVolumeSource)
                **out = **in
        }
        if in.AWSElasticBlockStore != nil {
                in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore
                *out = new(AWSElasticBlockStoreVolumeSource)
                **out = **in
        }
        if in.HostPath != nil {
                in, out := &in.HostPath, &out.HostPath
                *out = new(HostPathVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Glusterfs != nil {
                in, out := &in.Glusterfs, &out.Glusterfs
                *out = new(GlusterfsPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.NFS != nil {
                in, out := &in.NFS, &out.NFS
                *out = new(NFSVolumeSource)
                **out = **in
        }
        if in.RBD != nil {
                in, out := &in.RBD, &out.RBD
                *out = new(RBDPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Quobyte != nil {
                in, out := &in.Quobyte, &out.Quobyte
                *out = new(QuobyteVolumeSource)
                **out = **in
        }
        if in.ISCSI != nil {
                in, out := &in.ISCSI, &out.ISCSI
                *out = new(ISCSIPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.FlexVolume != nil {
                in, out := &in.FlexVolume, &out.FlexVolume
                *out = new(FlexPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Cinder != nil {
                in, out := &in.Cinder, &out.Cinder
                *out = new(CinderPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.CephFS != nil {
                in, out := &in.CephFS, &out.CephFS
                *out = new(CephFSPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.FC != nil {
                in, out := &in.FC, &out.FC
                *out = new(FCVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Flocker != nil {
                in, out := &in.Flocker, &out.Flocker
                *out = new(FlockerVolumeSource)
                **out = **in
        }
        if in.AzureFile != nil {
                in, out := &in.AzureFile, &out.AzureFile
                *out = new(AzureFilePersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.VsphereVolume != nil {
                in, out := &in.VsphereVolume, &out.VsphereVolume
                *out = new(VsphereVirtualDiskVolumeSource)
                **out = **in
        }
        if in.AzureDisk != nil {
                in, out := &in.AzureDisk, &out.AzureDisk
                *out = new(AzureDiskVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.PhotonPersistentDisk != nil {
                in, out := &in.PhotonPersistentDisk, &out.PhotonPersistentDisk
                *out = new(PhotonPersistentDiskVolumeSource)
                **out = **in
        }
        if in.PortworxVolume != nil {
                in, out := &in.PortworxVolume, &out.PortworxVolume
                *out = new(PortworxVolumeSource)
                **out = **in
        }
        if in.ScaleIO != nil {
                in, out := &in.ScaleIO, &out.ScaleIO
                *out = new(ScaleIOPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Local != nil {
                in, out := &in.Local, &out.Local
                *out = new(LocalVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.StorageOS != nil {
                in, out := &in.StorageOS, &out.StorageOS
                *out = new(StorageOSPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.CSI != nil {
                in, out := &in.CSI, &out.CSI
                *out = new(CSIPersistentVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeSource.
func (in *PersistentVolumeSource) DeepCopy() *PersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeSpec) DeepCopyInto(out *PersistentVolumeSpec) {
        *out = *in
        if in.Capacity != nil {
                in, out := &in.Capacity, &out.Capacity
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        in.PersistentVolumeSource.DeepCopyInto(&out.PersistentVolumeSource)
        if in.AccessModes != nil {
                in, out := &in.AccessModes, &out.AccessModes
                *out = make([]PersistentVolumeAccessMode, len(*in))
                copy(*out, *in)
        }
        if in.ClaimRef != nil {
                in, out := &in.ClaimRef, &out.ClaimRef
                *out = new(ObjectReference)
                **out = **in
        }
        if in.MountOptions != nil {
                in, out := &in.MountOptions, &out.MountOptions
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.VolumeMode != nil {
                in, out := &in.VolumeMode, &out.VolumeMode
                *out = new(PersistentVolumeMode)
                **out = **in
        }
        if in.NodeAffinity != nil {
                in, out := &in.NodeAffinity, &out.NodeAffinity
                *out = new(VolumeNodeAffinity)
                (*in).DeepCopyInto(*out)
        }
        if in.VolumeAttributesClassName != nil {
                in, out := &in.VolumeAttributesClassName, &out.VolumeAttributesClassName
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeSpec.
func (in *PersistentVolumeSpec) DeepCopy() *PersistentVolumeSpec {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PersistentVolumeStatus) DeepCopyInto(out *PersistentVolumeStatus) {
        *out = *in
        if in.LastPhaseTransitionTime != nil {
                in, out := &in.LastPhaseTransitionTime, &out.LastPhaseTransitionTime
                *out = (*in).DeepCopy()
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PersistentVolumeStatus.
func (in *PersistentVolumeStatus) DeepCopy() *PersistentVolumeStatus {
        if in == nil {
                return nil
        }
        out := new(PersistentVolumeStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PhotonPersistentDiskVolumeSource) DeepCopyInto(out *PhotonPersistentDiskVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PhotonPersistentDiskVolumeSource.
func (in *PhotonPersistentDiskVolumeSource) DeepCopy() *PhotonPersistentDiskVolumeSource {
        if in == nil {
                return nil
        }
        out := new(PhotonPersistentDiskVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Pod) DeepCopyInto(out *Pod) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Pod.
func (in *Pod) DeepCopy() *Pod {
        if in == nil {
                return nil
        }
        out := new(Pod)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Pod) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodAffinity) DeepCopyInto(out *PodAffinity) {
        *out = *in
        if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
                in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
                *out = make([]PodAffinityTerm, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
                in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
                *out = make([]WeightedPodAffinityTerm, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodAffinity.
func (in *PodAffinity) DeepCopy() *PodAffinity {
        if in == nil {
                return nil
        }
        out := new(PodAffinity)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodAffinityTerm) DeepCopyInto(out *PodAffinityTerm) {
        *out = *in
        if in.LabelSelector != nil {
                in, out := &in.LabelSelector, &out.LabelSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.Namespaces != nil {
                in, out := &in.Namespaces, &out.Namespaces
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.NamespaceSelector != nil {
                in, out := &in.NamespaceSelector, &out.NamespaceSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.MatchLabelKeys != nil {
                in, out := &in.MatchLabelKeys, &out.MatchLabelKeys
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.MismatchLabelKeys != nil {
                in, out := &in.MismatchLabelKeys, &out.MismatchLabelKeys
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodAffinityTerm.
func (in *PodAffinityTerm) DeepCopy() *PodAffinityTerm {
        if in == nil {
                return nil
        }
        out := new(PodAffinityTerm)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodAntiAffinity) DeepCopyInto(out *PodAntiAffinity) {
        *out = *in
        if in.RequiredDuringSchedulingIgnoredDuringExecution != nil {
                in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution
                *out = make([]PodAffinityTerm, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.PreferredDuringSchedulingIgnoredDuringExecution != nil {
                in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution
                *out = make([]WeightedPodAffinityTerm, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodAntiAffinity.
func (in *PodAntiAffinity) DeepCopy() *PodAntiAffinity {
        if in == nil {
                return nil
        }
        out := new(PodAntiAffinity)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodAttachOptions) DeepCopyInto(out *PodAttachOptions) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodAttachOptions.
func (in *PodAttachOptions) DeepCopy() *PodAttachOptions {
        if in == nil {
                return nil
        }
        out := new(PodAttachOptions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodAttachOptions) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodCertificateProjection) DeepCopyInto(out *PodCertificateProjection) {
        *out = *in
        if in.MaxExpirationSeconds != nil {
                in, out := &in.MaxExpirationSeconds, &out.MaxExpirationSeconds
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodCertificateProjection.
func (in *PodCertificateProjection) DeepCopy() *PodCertificateProjection {
        if in == nil {
                return nil
        }
        out := new(PodCertificateProjection)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodCondition) DeepCopyInto(out *PodCondition) {
        *out = *in
        in.LastProbeTime.DeepCopyInto(&out.LastProbeTime)
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodCondition.
func (in *PodCondition) DeepCopy() *PodCondition {
        if in == nil {
                return nil
        }
        out := new(PodCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodDNSConfig) DeepCopyInto(out *PodDNSConfig) {
        *out = *in
        if in.Nameservers != nil {
                in, out := &in.Nameservers, &out.Nameservers
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Searches != nil {
                in, out := &in.Searches, &out.Searches
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.Options != nil {
                in, out := &in.Options, &out.Options
                *out = make([]PodDNSConfigOption, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodDNSConfig.
func (in *PodDNSConfig) DeepCopy() *PodDNSConfig {
        if in == nil {
                return nil
        }
        out := new(PodDNSConfig)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodDNSConfigOption) DeepCopyInto(out *PodDNSConfigOption) {
        *out = *in
        if in.Value != nil {
                in, out := &in.Value, &out.Value
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodDNSConfigOption.
func (in *PodDNSConfigOption) DeepCopy() *PodDNSConfigOption {
        if in == nil {
                return nil
        }
        out := new(PodDNSConfigOption)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodExecOptions) DeepCopyInto(out *PodExecOptions) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        if in.Command != nil {
                in, out := &in.Command, &out.Command
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodExecOptions.
func (in *PodExecOptions) DeepCopy() *PodExecOptions {
        if in == nil {
                return nil
        }
        out := new(PodExecOptions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodExecOptions) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodExtendedResourceClaimStatus) DeepCopyInto(out *PodExtendedResourceClaimStatus) {
        *out = *in
        if in.RequestMappings != nil {
                in, out := &in.RequestMappings, &out.RequestMappings
                *out = make([]ContainerExtendedResourceRequest, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodExtendedResourceClaimStatus.
func (in *PodExtendedResourceClaimStatus) DeepCopy() *PodExtendedResourceClaimStatus {
        if in == nil {
                return nil
        }
        out := new(PodExtendedResourceClaimStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodIP) DeepCopyInto(out *PodIP) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodIP.
func (in *PodIP) DeepCopy() *PodIP {
        if in == nil {
                return nil
        }
        out := new(PodIP)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodList) DeepCopyInto(out *PodList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Pod, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodList.
func (in *PodList) DeepCopy() *PodList {
        if in == nil {
                return nil
        }
        out := new(PodList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodLogOptions) DeepCopyInto(out *PodLogOptions) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        if in.SinceSeconds != nil {
                in, out := &in.SinceSeconds, &out.SinceSeconds
                *out = new(int64)
                **out = **in
        }
        if in.SinceTime != nil {
                in, out := &in.SinceTime, &out.SinceTime
                *out = (*in).DeepCopy()
        }
        if in.TailLines != nil {
                in, out := &in.TailLines, &out.TailLines
                *out = new(int64)
                **out = **in
        }
        if in.LimitBytes != nil {
                in, out := &in.LimitBytes, &out.LimitBytes
                *out = new(int64)
                **out = **in
        }
        if in.Stream != nil {
                in, out := &in.Stream, &out.Stream
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodLogOptions.
func (in *PodLogOptions) DeepCopy() *PodLogOptions {
        if in == nil {
                return nil
        }
        out := new(PodLogOptions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodLogOptions) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodOS) DeepCopyInto(out *PodOS) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodOS.
func (in *PodOS) DeepCopy() *PodOS {
        if in == nil {
                return nil
        }
        out := new(PodOS)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodPortForwardOptions) DeepCopyInto(out *PodPortForwardOptions) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        if in.Ports != nil {
                in, out := &in.Ports, &out.Ports
                *out = make([]int32, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodPortForwardOptions.
func (in *PodPortForwardOptions) DeepCopy() *PodPortForwardOptions {
        if in == nil {
                return nil
        }
        out := new(PodPortForwardOptions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodPortForwardOptions) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodProxyOptions) DeepCopyInto(out *PodProxyOptions) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodProxyOptions.
func (in *PodProxyOptions) DeepCopy() *PodProxyOptions {
        if in == nil {
                return nil
        }
        out := new(PodProxyOptions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodProxyOptions) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodReadinessGate) DeepCopyInto(out *PodReadinessGate) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodReadinessGate.
func (in *PodReadinessGate) DeepCopy() *PodReadinessGate {
        if in == nil {
                return nil
        }
        out := new(PodReadinessGate)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodResourceClaim) DeepCopyInto(out *PodResourceClaim) {
        *out = *in
        if in.ResourceClaimName != nil {
                in, out := &in.ResourceClaimName, &out.ResourceClaimName
                *out = new(string)
                **out = **in
        }
        if in.ResourceClaimTemplateName != nil {
                in, out := &in.ResourceClaimTemplateName, &out.ResourceClaimTemplateName
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodResourceClaim.
func (in *PodResourceClaim) DeepCopy() *PodResourceClaim {
        if in == nil {
                return nil
        }
        out := new(PodResourceClaim)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodResourceClaimStatus) DeepCopyInto(out *PodResourceClaimStatus) {
        *out = *in
        if in.ResourceClaimName != nil {
                in, out := &in.ResourceClaimName, &out.ResourceClaimName
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodResourceClaimStatus.
func (in *PodResourceClaimStatus) DeepCopy() *PodResourceClaimStatus {
        if in == nil {
                return nil
        }
        out := new(PodResourceClaimStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodSchedulingGate) DeepCopyInto(out *PodSchedulingGate) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSchedulingGate.
func (in *PodSchedulingGate) DeepCopy() *PodSchedulingGate {
        if in == nil {
                return nil
        }
        out := new(PodSchedulingGate)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodSecurityContext) DeepCopyInto(out *PodSecurityContext) {
        *out = *in
        if in.ShareProcessNamespace != nil {
                in, out := &in.ShareProcessNamespace, &out.ShareProcessNamespace
                *out = new(bool)
                **out = **in
        }
        if in.HostUsers != nil {
                in, out := &in.HostUsers, &out.HostUsers
                *out = new(bool)
                **out = **in
        }
        if in.SELinuxOptions != nil {
                in, out := &in.SELinuxOptions, &out.SELinuxOptions
                *out = new(SELinuxOptions)
                **out = **in
        }
        if in.WindowsOptions != nil {
                in, out := &in.WindowsOptions, &out.WindowsOptions
                *out = new(WindowsSecurityContextOptions)
                (*in).DeepCopyInto(*out)
        }
        if in.RunAsUser != nil {
                in, out := &in.RunAsUser, &out.RunAsUser
                *out = new(int64)
                **out = **in
        }
        if in.RunAsGroup != nil {
                in, out := &in.RunAsGroup, &out.RunAsGroup
                *out = new(int64)
                **out = **in
        }
        if in.RunAsNonRoot != nil {
                in, out := &in.RunAsNonRoot, &out.RunAsNonRoot
                *out = new(bool)
                **out = **in
        }
        if in.SupplementalGroups != nil {
                in, out := &in.SupplementalGroups, &out.SupplementalGroups
                *out = make([]int64, len(*in))
                copy(*out, *in)
        }
        if in.SupplementalGroupsPolicy != nil {
                in, out := &in.SupplementalGroupsPolicy, &out.SupplementalGroupsPolicy
                *out = new(SupplementalGroupsPolicy)
                **out = **in
        }
        if in.FSGroup != nil {
                in, out := &in.FSGroup, &out.FSGroup
                *out = new(int64)
                **out = **in
        }
        if in.FSGroupChangePolicy != nil {
                in, out := &in.FSGroupChangePolicy, &out.FSGroupChangePolicy
                *out = new(PodFSGroupChangePolicy)
                **out = **in
        }
        if in.Sysctls != nil {
                in, out := &in.Sysctls, &out.Sysctls
                *out = make([]Sysctl, len(*in))
                copy(*out, *in)
        }
        if in.SeccompProfile != nil {
                in, out := &in.SeccompProfile, &out.SeccompProfile
                *out = new(SeccompProfile)
                (*in).DeepCopyInto(*out)
        }
        if in.AppArmorProfile != nil {
                in, out := &in.AppArmorProfile, &out.AppArmorProfile
                *out = new(AppArmorProfile)
                (*in).DeepCopyInto(*out)
        }
        if in.SELinuxChangePolicy != nil {
                in, out := &in.SELinuxChangePolicy, &out.SELinuxChangePolicy
                *out = new(PodSELinuxChangePolicy)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSecurityContext.
func (in *PodSecurityContext) DeepCopy() *PodSecurityContext {
        if in == nil {
                return nil
        }
        out := new(PodSecurityContext)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodSignature) DeepCopyInto(out *PodSignature) {
        *out = *in
        if in.PodController != nil {
                in, out := &in.PodController, &out.PodController
                *out = new(v1.OwnerReference)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSignature.
func (in *PodSignature) DeepCopy() *PodSignature {
        if in == nil {
                return nil
        }
        out := new(PodSignature)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodSpec) DeepCopyInto(out *PodSpec) {
        *out = *in
        if in.Volumes != nil {
                in, out := &in.Volumes, &out.Volumes
                *out = make([]Volume, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.InitContainers != nil {
                in, out := &in.InitContainers, &out.InitContainers
                *out = make([]Container, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Containers != nil {
                in, out := &in.Containers, &out.Containers
                *out = make([]Container, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.EphemeralContainers != nil {
                in, out := &in.EphemeralContainers, &out.EphemeralContainers
                *out = make([]EphemeralContainer, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.TerminationGracePeriodSeconds != nil {
                in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds
                *out = new(int64)
                **out = **in
        }
        if in.ActiveDeadlineSeconds != nil {
                in, out := &in.ActiveDeadlineSeconds, &out.ActiveDeadlineSeconds
                *out = new(int64)
                **out = **in
        }
        if in.NodeSelector != nil {
                in, out := &in.NodeSelector, &out.NodeSelector
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.AutomountServiceAccountToken != nil {
                in, out := &in.AutomountServiceAccountToken, &out.AutomountServiceAccountToken
                *out = new(bool)
                **out = **in
        }
        if in.SecurityContext != nil {
                in, out := &in.SecurityContext, &out.SecurityContext
                *out = new(PodSecurityContext)
                (*in).DeepCopyInto(*out)
        }
        if in.ImagePullSecrets != nil {
                in, out := &in.ImagePullSecrets, &out.ImagePullSecrets
                *out = make([]LocalObjectReference, len(*in))
                copy(*out, *in)
        }
        if in.SetHostnameAsFQDN != nil {
                in, out := &in.SetHostnameAsFQDN, &out.SetHostnameAsFQDN
                *out = new(bool)
                **out = **in
        }
        if in.Affinity != nil {
                in, out := &in.Affinity, &out.Affinity
                *out = new(Affinity)
                (*in).DeepCopyInto(*out)
        }
        if in.Tolerations != nil {
                in, out := &in.Tolerations, &out.Tolerations
                *out = make([]Toleration, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.HostAliases != nil {
                in, out := &in.HostAliases, &out.HostAliases
                *out = make([]HostAlias, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Priority != nil {
                in, out := &in.Priority, &out.Priority
                *out = new(int32)
                **out = **in
        }
        if in.PreemptionPolicy != nil {
                in, out := &in.PreemptionPolicy, &out.PreemptionPolicy
                *out = new(PreemptionPolicy)
                **out = **in
        }
        if in.DNSConfig != nil {
                in, out := &in.DNSConfig, &out.DNSConfig
                *out = new(PodDNSConfig)
                (*in).DeepCopyInto(*out)
        }
        if in.ReadinessGates != nil {
                in, out := &in.ReadinessGates, &out.ReadinessGates
                *out = make([]PodReadinessGate, len(*in))
                copy(*out, *in)
        }
        if in.RuntimeClassName != nil {
                in, out := &in.RuntimeClassName, &out.RuntimeClassName
                *out = new(string)
                **out = **in
        }
        if in.Overhead != nil {
                in, out := &in.Overhead, &out.Overhead
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.EnableServiceLinks != nil {
                in, out := &in.EnableServiceLinks, &out.EnableServiceLinks
                *out = new(bool)
                **out = **in
        }
        if in.TopologySpreadConstraints != nil {
                in, out := &in.TopologySpreadConstraints, &out.TopologySpreadConstraints
                *out = make([]TopologySpreadConstraint, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.OS != nil {
                in, out := &in.OS, &out.OS
                *out = new(PodOS)
                **out = **in
        }
        if in.SchedulingGates != nil {
                in, out := &in.SchedulingGates, &out.SchedulingGates
                *out = make([]PodSchedulingGate, len(*in))
                copy(*out, *in)
        }
        if in.ResourceClaims != nil {
                in, out := &in.ResourceClaims, &out.ResourceClaims
                *out = make([]PodResourceClaim, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Resources != nil {
                in, out := &in.Resources, &out.Resources
                *out = new(ResourceRequirements)
                (*in).DeepCopyInto(*out)
        }
        if in.HostnameOverride != nil {
                in, out := &in.HostnameOverride, &out.HostnameOverride
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodSpec.
func (in *PodSpec) DeepCopy() *PodSpec {
        if in == nil {
                return nil
        }
        out := new(PodSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodStatus) DeepCopyInto(out *PodStatus) {
        *out = *in
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]PodCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.HostIPs != nil {
                in, out := &in.HostIPs, &out.HostIPs
                *out = make([]HostIP, len(*in))
                copy(*out, *in)
        }
        if in.PodIPs != nil {
                in, out := &in.PodIPs, &out.PodIPs
                *out = make([]PodIP, len(*in))
                copy(*out, *in)
        }
        if in.StartTime != nil {
                in, out := &in.StartTime, &out.StartTime
                *out = (*in).DeepCopy()
        }
        if in.InitContainerStatuses != nil {
                in, out := &in.InitContainerStatuses, &out.InitContainerStatuses
                *out = make([]ContainerStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.ContainerStatuses != nil {
                in, out := &in.ContainerStatuses, &out.ContainerStatuses
                *out = make([]ContainerStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.EphemeralContainerStatuses != nil {
                in, out := &in.EphemeralContainerStatuses, &out.EphemeralContainerStatuses
                *out = make([]ContainerStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.ResourceClaimStatuses != nil {
                in, out := &in.ResourceClaimStatuses, &out.ResourceClaimStatuses
                *out = make([]PodResourceClaimStatus, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.ExtendedResourceClaimStatus != nil {
                in, out := &in.ExtendedResourceClaimStatus, &out.ExtendedResourceClaimStatus
                *out = new(PodExtendedResourceClaimStatus)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodStatus.
func (in *PodStatus) DeepCopy() *PodStatus {
        if in == nil {
                return nil
        }
        out := new(PodStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodStatusResult) DeepCopyInto(out *PodStatusResult) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodStatusResult.
func (in *PodStatusResult) DeepCopy() *PodStatusResult {
        if in == nil {
                return nil
        }
        out := new(PodStatusResult)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodStatusResult) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodTemplate) DeepCopyInto(out *PodTemplate) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Template.DeepCopyInto(&out.Template)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodTemplate.
func (in *PodTemplate) DeepCopy() *PodTemplate {
        if in == nil {
                return nil
        }
        out := new(PodTemplate)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodTemplate) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodTemplateList) DeepCopyInto(out *PodTemplateList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]PodTemplate, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodTemplateList.
func (in *PodTemplateList) DeepCopy() *PodTemplateList {
        if in == nil {
                return nil
        }
        out := new(PodTemplateList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *PodTemplateList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PodTemplateSpec) DeepCopyInto(out *PodTemplateSpec) {
        *out = *in
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodTemplateSpec.
func (in *PodTemplateSpec) DeepCopy() *PodTemplateSpec {
        if in == nil {
                return nil
        }
        out := new(PodTemplateSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PortStatus) DeepCopyInto(out *PortStatus) {
        *out = *in
        if in.Error != nil {
                in, out := &in.Error, &out.Error
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PortStatus.
func (in *PortStatus) DeepCopy() *PortStatus {
        if in == nil {
                return nil
        }
        out := new(PortStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PortworxVolumeSource) DeepCopyInto(out *PortworxVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PortworxVolumeSource.
func (in *PortworxVolumeSource) DeepCopy() *PortworxVolumeSource {
        if in == nil {
                return nil
        }
        out := new(PortworxVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Preconditions) DeepCopyInto(out *Preconditions) {
        *out = *in
        if in.UID != nil {
                in, out := &in.UID, &out.UID
                *out = new(types.UID)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Preconditions.
func (in *Preconditions) DeepCopy() *Preconditions {
        if in == nil {
                return nil
        }
        out := new(Preconditions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PreferAvoidPodsEntry) DeepCopyInto(out *PreferAvoidPodsEntry) {
        *out = *in
        in.PodSignature.DeepCopyInto(&out.PodSignature)
        in.EvictionTime.DeepCopyInto(&out.EvictionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PreferAvoidPodsEntry.
func (in *PreferAvoidPodsEntry) DeepCopy() *PreferAvoidPodsEntry {
        if in == nil {
                return nil
        }
        out := new(PreferAvoidPodsEntry)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PreferredSchedulingTerm) DeepCopyInto(out *PreferredSchedulingTerm) {
        *out = *in
        in.Preference.DeepCopyInto(&out.Preference)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PreferredSchedulingTerm.
func (in *PreferredSchedulingTerm) DeepCopy() *PreferredSchedulingTerm {
        if in == nil {
                return nil
        }
        out := new(PreferredSchedulingTerm)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Probe) DeepCopyInto(out *Probe) {
        *out = *in
        in.ProbeHandler.DeepCopyInto(&out.ProbeHandler)
        if in.TerminationGracePeriodSeconds != nil {
                in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds
                *out = new(int64)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Probe.
func (in *Probe) DeepCopy() *Probe {
        if in == nil {
                return nil
        }
        out := new(Probe)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ProbeHandler) DeepCopyInto(out *ProbeHandler) {
        *out = *in
        if in.Exec != nil {
                in, out := &in.Exec, &out.Exec
                *out = new(ExecAction)
                (*in).DeepCopyInto(*out)
        }
        if in.HTTPGet != nil {
                in, out := &in.HTTPGet, &out.HTTPGet
                *out = new(HTTPGetAction)
                (*in).DeepCopyInto(*out)
        }
        if in.TCPSocket != nil {
                in, out := &in.TCPSocket, &out.TCPSocket
                *out = new(TCPSocketAction)
                **out = **in
        }
        if in.GRPC != nil {
                in, out := &in.GRPC, &out.GRPC
                *out = new(GRPCAction)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProbeHandler.
func (in *ProbeHandler) DeepCopy() *ProbeHandler {
        if in == nil {
                return nil
        }
        out := new(ProbeHandler)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ProjectedVolumeSource) DeepCopyInto(out *ProjectedVolumeSource) {
        *out = *in
        if in.Sources != nil {
                in, out := &in.Sources, &out.Sources
                *out = make([]VolumeProjection, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.DefaultMode != nil {
                in, out := &in.DefaultMode, &out.DefaultMode
                *out = new(int32)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ProjectedVolumeSource.
func (in *ProjectedVolumeSource) DeepCopy() *ProjectedVolumeSource {
        if in == nil {
                return nil
        }
        out := new(ProjectedVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *QuobyteVolumeSource) DeepCopyInto(out *QuobyteVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QuobyteVolumeSource.
func (in *QuobyteVolumeSource) DeepCopy() *QuobyteVolumeSource {
        if in == nil {
                return nil
        }
        out := new(QuobyteVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RBDPersistentVolumeSource) DeepCopyInto(out *RBDPersistentVolumeSource) {
        *out = *in
        if in.CephMonitors != nil {
                in, out := &in.CephMonitors, &out.CephMonitors
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(SecretReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RBDPersistentVolumeSource.
func (in *RBDPersistentVolumeSource) DeepCopy() *RBDPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(RBDPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RBDVolumeSource) DeepCopyInto(out *RBDVolumeSource) {
        *out = *in
        if in.CephMonitors != nil {
                in, out := &in.CephMonitors, &out.CephMonitors
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(LocalObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RBDVolumeSource.
func (in *RBDVolumeSource) DeepCopy() *RBDVolumeSource {
        if in == nil {
                return nil
        }
        out := new(RBDVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *RangeAllocation) DeepCopyInto(out *RangeAllocation) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Data != nil {
                in, out := &in.Data, &out.Data
                *out = make([]byte, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RangeAllocation.
func (in *RangeAllocation) DeepCopy() *RangeAllocation {
        if in == nil {
                return nil
        }
        out := new(RangeAllocation)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *RangeAllocation) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicationController) DeepCopyInto(out *ReplicationController) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicationController.
func (in *ReplicationController) DeepCopy() *ReplicationController {
        if in == nil {
                return nil
        }
        out := new(ReplicationController)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ReplicationController) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicationControllerCondition) DeepCopyInto(out *ReplicationControllerCondition) {
        *out = *in
        in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicationControllerCondition.
func (in *ReplicationControllerCondition) DeepCopy() *ReplicationControllerCondition {
        if in == nil {
                return nil
        }
        out := new(ReplicationControllerCondition)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicationControllerList) DeepCopyInto(out *ReplicationControllerList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ReplicationController, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicationControllerList.
func (in *ReplicationControllerList) DeepCopy() *ReplicationControllerList {
        if in == nil {
                return nil
        }
        out := new(ReplicationControllerList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ReplicationControllerList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicationControllerSpec) DeepCopyInto(out *ReplicationControllerSpec) {
        *out = *in
        if in.Replicas != nil {
                in, out := &in.Replicas, &out.Replicas
                *out = new(int32)
                **out = **in
        }
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.Template != nil {
                in, out := &in.Template, &out.Template
                *out = new(PodTemplateSpec)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicationControllerSpec.
func (in *ReplicationControllerSpec) DeepCopy() *ReplicationControllerSpec {
        if in == nil {
                return nil
        }
        out := new(ReplicationControllerSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReplicationControllerStatus) DeepCopyInto(out *ReplicationControllerStatus) {
        *out = *in
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]ReplicationControllerCondition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicationControllerStatus.
func (in *ReplicationControllerStatus) DeepCopy() *ReplicationControllerStatus {
        if in == nil {
                return nil
        }
        out := new(ReplicationControllerStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceClaim) DeepCopyInto(out *ResourceClaim) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceClaim.
func (in *ResourceClaim) DeepCopy() *ResourceClaim {
        if in == nil {
                return nil
        }
        out := new(ResourceClaim)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceFieldSelector) DeepCopyInto(out *ResourceFieldSelector) {
        *out = *in
        out.Divisor = in.Divisor.DeepCopy()
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceFieldSelector.
func (in *ResourceFieldSelector) DeepCopy() *ResourceFieldSelector {
        if in == nil {
                return nil
        }
        out := new(ResourceFieldSelector)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceHealth) DeepCopyInto(out *ResourceHealth) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceHealth.
func (in *ResourceHealth) DeepCopy() *ResourceHealth {
        if in == nil {
                return nil
        }
        out := new(ResourceHealth)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in ResourceList) DeepCopyInto(out *ResourceList) {
        {
                in := &in
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
                return
        }
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceList.
func (in ResourceList) DeepCopy() ResourceList {
        if in == nil {
                return nil
        }
        out := new(ResourceList)
        in.DeepCopyInto(out)
        return *out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceQuota) DeepCopyInto(out *ResourceQuota) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceQuota.
func (in *ResourceQuota) DeepCopy() *ResourceQuota {
        if in == nil {
                return nil
        }
        out := new(ResourceQuota)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ResourceQuota) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceQuotaList) DeepCopyInto(out *ResourceQuotaList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ResourceQuota, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceQuotaList.
func (in *ResourceQuotaList) DeepCopy() *ResourceQuotaList {
        if in == nil {
                return nil
        }
        out := new(ResourceQuotaList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ResourceQuotaList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceQuotaSpec) DeepCopyInto(out *ResourceQuotaSpec) {
        *out = *in
        if in.Hard != nil {
                in, out := &in.Hard, &out.Hard
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Scopes != nil {
                in, out := &in.Scopes, &out.Scopes
                *out = make([]ResourceQuotaScope, len(*in))
                copy(*out, *in)
        }
        if in.ScopeSelector != nil {
                in, out := &in.ScopeSelector, &out.ScopeSelector
                *out = new(ScopeSelector)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceQuotaSpec.
func (in *ResourceQuotaSpec) DeepCopy() *ResourceQuotaSpec {
        if in == nil {
                return nil
        }
        out := new(ResourceQuotaSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceQuotaStatus) DeepCopyInto(out *ResourceQuotaStatus) {
        *out = *in
        if in.Hard != nil {
                in, out := &in.Hard, &out.Hard
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Used != nil {
                in, out := &in.Used, &out.Used
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceQuotaStatus.
func (in *ResourceQuotaStatus) DeepCopy() *ResourceQuotaStatus {
        if in == nil {
                return nil
        }
        out := new(ResourceQuotaStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceRequirements) DeepCopyInto(out *ResourceRequirements) {
        *out = *in
        if in.Limits != nil {
                in, out := &in.Limits, &out.Limits
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Requests != nil {
                in, out := &in.Requests, &out.Requests
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Claims != nil {
                in, out := &in.Claims, &out.Claims
                *out = make([]ResourceClaim, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceRequirements.
func (in *ResourceRequirements) DeepCopy() *ResourceRequirements {
        if in == nil {
                return nil
        }
        out := new(ResourceRequirements)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ResourceStatus) DeepCopyInto(out *ResourceStatus) {
        *out = *in
        if in.Resources != nil {
                in, out := &in.Resources, &out.Resources
                *out = make([]ResourceHealth, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceStatus.
func (in *ResourceStatus) DeepCopy() *ResourceStatus {
        if in == nil {
                return nil
        }
        out := new(ResourceStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SELinuxOptions) DeepCopyInto(out *SELinuxOptions) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SELinuxOptions.
func (in *SELinuxOptions) DeepCopy() *SELinuxOptions {
        if in == nil {
                return nil
        }
        out := new(SELinuxOptions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ScaleIOPersistentVolumeSource) DeepCopyInto(out *ScaleIOPersistentVolumeSource) {
        *out = *in
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(SecretReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScaleIOPersistentVolumeSource.
func (in *ScaleIOPersistentVolumeSource) DeepCopy() *ScaleIOPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(ScaleIOPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ScaleIOVolumeSource) DeepCopyInto(out *ScaleIOVolumeSource) {
        *out = *in
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(LocalObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScaleIOVolumeSource.
func (in *ScaleIOVolumeSource) DeepCopy() *ScaleIOVolumeSource {
        if in == nil {
                return nil
        }
        out := new(ScaleIOVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ScopeSelector) DeepCopyInto(out *ScopeSelector) {
        *out = *in
        if in.MatchExpressions != nil {
                in, out := &in.MatchExpressions, &out.MatchExpressions
                *out = make([]ScopedResourceSelectorRequirement, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScopeSelector.
func (in *ScopeSelector) DeepCopy() *ScopeSelector {
        if in == nil {
                return nil
        }
        out := new(ScopeSelector)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ScopedResourceSelectorRequirement) DeepCopyInto(out *ScopedResourceSelectorRequirement) {
        *out = *in
        if in.Values != nil {
                in, out := &in.Values, &out.Values
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScopedResourceSelectorRequirement.
func (in *ScopedResourceSelectorRequirement) DeepCopy() *ScopedResourceSelectorRequirement {
        if in == nil {
                return nil
        }
        out := new(ScopedResourceSelectorRequirement)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SeccompProfile) DeepCopyInto(out *SeccompProfile) {
        *out = *in
        if in.LocalhostProfile != nil {
                in, out := &in.LocalhostProfile, &out.LocalhostProfile
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SeccompProfile.
func (in *SeccompProfile) DeepCopy() *SeccompProfile {
        if in == nil {
                return nil
        }
        out := new(SeccompProfile)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Secret) DeepCopyInto(out *Secret) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Immutable != nil {
                in, out := &in.Immutable, &out.Immutable
                *out = new(bool)
                **out = **in
        }
        if in.Data != nil {
                in, out := &in.Data, &out.Data
                *out = make(map[string][]byte, len(*in))
                for key, val := range *in {
                        var outVal []byte
                        if val == nil {
                                (*out)[key] = nil
                        } else {
                                in, out := &val, &outVal
                                *out = make([]byte, len(*in))
                                copy(*out, *in)
                        }
                        (*out)[key] = outVal
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Secret.
func (in *Secret) DeepCopy() *Secret {
        if in == nil {
                return nil
        }
        out := new(Secret)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Secret) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SecretEnvSource) DeepCopyInto(out *SecretEnvSource) {
        *out = *in
        out.LocalObjectReference = in.LocalObjectReference
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretEnvSource.
func (in *SecretEnvSource) DeepCopy() *SecretEnvSource {
        if in == nil {
                return nil
        }
        out := new(SecretEnvSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SecretKeySelector) DeepCopyInto(out *SecretKeySelector) {
        *out = *in
        out.LocalObjectReference = in.LocalObjectReference
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretKeySelector.
func (in *SecretKeySelector) DeepCopy() *SecretKeySelector {
        if in == nil {
                return nil
        }
        out := new(SecretKeySelector)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SecretList) DeepCopyInto(out *SecretList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Secret, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretList.
func (in *SecretList) DeepCopy() *SecretList {
        if in == nil {
                return nil
        }
        out := new(SecretList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *SecretList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SecretProjection) DeepCopyInto(out *SecretProjection) {
        *out = *in
        out.LocalObjectReference = in.LocalObjectReference
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]KeyToPath, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretProjection.
func (in *SecretProjection) DeepCopy() *SecretProjection {
        if in == nil {
                return nil
        }
        out := new(SecretProjection)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SecretReference) DeepCopyInto(out *SecretReference) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretReference.
func (in *SecretReference) DeepCopy() *SecretReference {
        if in == nil {
                return nil
        }
        out := new(SecretReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SecretVolumeSource) DeepCopyInto(out *SecretVolumeSource) {
        *out = *in
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]KeyToPath, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.DefaultMode != nil {
                in, out := &in.DefaultMode, &out.DefaultMode
                *out = new(int32)
                **out = **in
        }
        if in.Optional != nil {
                in, out := &in.Optional, &out.Optional
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretVolumeSource.
func (in *SecretVolumeSource) DeepCopy() *SecretVolumeSource {
        if in == nil {
                return nil
        }
        out := new(SecretVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SecurityContext) DeepCopyInto(out *SecurityContext) {
        *out = *in
        if in.Capabilities != nil {
                in, out := &in.Capabilities, &out.Capabilities
                *out = new(Capabilities)
                (*in).DeepCopyInto(*out)
        }
        if in.Privileged != nil {
                in, out := &in.Privileged, &out.Privileged
                *out = new(bool)
                **out = **in
        }
        if in.SELinuxOptions != nil {
                in, out := &in.SELinuxOptions, &out.SELinuxOptions
                *out = new(SELinuxOptions)
                **out = **in
        }
        if in.WindowsOptions != nil {
                in, out := &in.WindowsOptions, &out.WindowsOptions
                *out = new(WindowsSecurityContextOptions)
                (*in).DeepCopyInto(*out)
        }
        if in.RunAsUser != nil {
                in, out := &in.RunAsUser, &out.RunAsUser
                *out = new(int64)
                **out = **in
        }
        if in.RunAsGroup != nil {
                in, out := &in.RunAsGroup, &out.RunAsGroup
                *out = new(int64)
                **out = **in
        }
        if in.RunAsNonRoot != nil {
                in, out := &in.RunAsNonRoot, &out.RunAsNonRoot
                *out = new(bool)
                **out = **in
        }
        if in.ReadOnlyRootFilesystem != nil {
                in, out := &in.ReadOnlyRootFilesystem, &out.ReadOnlyRootFilesystem
                *out = new(bool)
                **out = **in
        }
        if in.AllowPrivilegeEscalation != nil {
                in, out := &in.AllowPrivilegeEscalation, &out.AllowPrivilegeEscalation
                *out = new(bool)
                **out = **in
        }
        if in.ProcMount != nil {
                in, out := &in.ProcMount, &out.ProcMount
                *out = new(ProcMountType)
                **out = **in
        }
        if in.SeccompProfile != nil {
                in, out := &in.SeccompProfile, &out.SeccompProfile
                *out = new(SeccompProfile)
                (*in).DeepCopyInto(*out)
        }
        if in.AppArmorProfile != nil {
                in, out := &in.AppArmorProfile, &out.AppArmorProfile
                *out = new(AppArmorProfile)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecurityContext.
func (in *SecurityContext) DeepCopy() *SecurityContext {
        if in == nil {
                return nil
        }
        out := new(SecurityContext)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SerializedReference) DeepCopyInto(out *SerializedReference) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        out.Reference = in.Reference
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SerializedReference.
func (in *SerializedReference) DeepCopy() *SerializedReference {
        if in == nil {
                return nil
        }
        out := new(SerializedReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *SerializedReference) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Service) DeepCopyInto(out *Service) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        in.Spec.DeepCopyInto(&out.Spec)
        in.Status.DeepCopyInto(&out.Status)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Service.
func (in *Service) DeepCopy() *Service {
        if in == nil {
                return nil
        }
        out := new(Service)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *Service) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServiceAccount) DeepCopyInto(out *ServiceAccount) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Secrets != nil {
                in, out := &in.Secrets, &out.Secrets
                *out = make([]ObjectReference, len(*in))
                copy(*out, *in)
        }
        if in.ImagePullSecrets != nil {
                in, out := &in.ImagePullSecrets, &out.ImagePullSecrets
                *out = make([]LocalObjectReference, len(*in))
                copy(*out, *in)
        }
        if in.AutomountServiceAccountToken != nil {
                in, out := &in.AutomountServiceAccountToken, &out.AutomountServiceAccountToken
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceAccount.
func (in *ServiceAccount) DeepCopy() *ServiceAccount {
        if in == nil {
                return nil
        }
        out := new(ServiceAccount)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ServiceAccount) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServiceAccountList) DeepCopyInto(out *ServiceAccountList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]ServiceAccount, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceAccountList.
func (in *ServiceAccountList) DeepCopy() *ServiceAccountList {
        if in == nil {
                return nil
        }
        out := new(ServiceAccountList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ServiceAccountList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServiceAccountTokenProjection) DeepCopyInto(out *ServiceAccountTokenProjection) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceAccountTokenProjection.
func (in *ServiceAccountTokenProjection) DeepCopy() *ServiceAccountTokenProjection {
        if in == nil {
                return nil
        }
        out := new(ServiceAccountTokenProjection)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServiceList) DeepCopyInto(out *ServiceList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]Service, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceList.
func (in *ServiceList) DeepCopy() *ServiceList {
        if in == nil {
                return nil
        }
        out := new(ServiceList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ServiceList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServicePort) DeepCopyInto(out *ServicePort) {
        *out = *in
        if in.AppProtocol != nil {
                in, out := &in.AppProtocol, &out.AppProtocol
                *out = new(string)
                **out = **in
        }
        out.TargetPort = in.TargetPort
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServicePort.
func (in *ServicePort) DeepCopy() *ServicePort {
        if in == nil {
                return nil
        }
        out := new(ServicePort)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServiceProxyOptions) DeepCopyInto(out *ServiceProxyOptions) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceProxyOptions.
func (in *ServiceProxyOptions) DeepCopy() *ServiceProxyOptions {
        if in == nil {
                return nil
        }
        out := new(ServiceProxyOptions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *ServiceProxyOptions) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServiceSpec) DeepCopyInto(out *ServiceSpec) {
        *out = *in
        if in.Ports != nil {
                in, out := &in.Ports, &out.Ports
                *out = make([]ServicePort, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Selector != nil {
                in, out := &in.Selector, &out.Selector
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.ClusterIPs != nil {
                in, out := &in.ClusterIPs, &out.ClusterIPs
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.IPFamilies != nil {
                in, out := &in.IPFamilies, &out.IPFamilies
                *out = make([]IPFamily, len(*in))
                copy(*out, *in)
        }
        if in.IPFamilyPolicy != nil {
                in, out := &in.IPFamilyPolicy, &out.IPFamilyPolicy
                *out = new(IPFamilyPolicy)
                **out = **in
        }
        if in.ExternalIPs != nil {
                in, out := &in.ExternalIPs, &out.ExternalIPs
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.SessionAffinityConfig != nil {
                in, out := &in.SessionAffinityConfig, &out.SessionAffinityConfig
                *out = new(SessionAffinityConfig)
                (*in).DeepCopyInto(*out)
        }
        if in.LoadBalancerSourceRanges != nil {
                in, out := &in.LoadBalancerSourceRanges, &out.LoadBalancerSourceRanges
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        if in.AllocateLoadBalancerNodePorts != nil {
                in, out := &in.AllocateLoadBalancerNodePorts, &out.AllocateLoadBalancerNodePorts
                *out = new(bool)
                **out = **in
        }
        if in.LoadBalancerClass != nil {
                in, out := &in.LoadBalancerClass, &out.LoadBalancerClass
                *out = new(string)
                **out = **in
        }
        if in.InternalTrafficPolicy != nil {
                in, out := &in.InternalTrafficPolicy, &out.InternalTrafficPolicy
                *out = new(ServiceInternalTrafficPolicy)
                **out = **in
        }
        if in.TrafficDistribution != nil {
                in, out := &in.TrafficDistribution, &out.TrafficDistribution
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceSpec.
func (in *ServiceSpec) DeepCopy() *ServiceSpec {
        if in == nil {
                return nil
        }
        out := new(ServiceSpec)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ServiceStatus) DeepCopyInto(out *ServiceStatus) {
        *out = *in
        in.LoadBalancer.DeepCopyInto(&out.LoadBalancer)
        if in.Conditions != nil {
                in, out := &in.Conditions, &out.Conditions
                *out = make([]v1.Condition, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceStatus.
func (in *ServiceStatus) DeepCopy() *ServiceStatus {
        if in == nil {
                return nil
        }
        out := new(ServiceStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SessionAffinityConfig) DeepCopyInto(out *SessionAffinityConfig) {
        *out = *in
        if in.ClientIP != nil {
                in, out := &in.ClientIP, &out.ClientIP
                *out = new(ClientIPConfig)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SessionAffinityConfig.
func (in *SessionAffinityConfig) DeepCopy() *SessionAffinityConfig {
        if in == nil {
                return nil
        }
        out := new(SessionAffinityConfig)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *SleepAction) DeepCopyInto(out *SleepAction) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SleepAction.
func (in *SleepAction) DeepCopy() *SleepAction {
        if in == nil {
                return nil
        }
        out := new(SleepAction)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StorageOSPersistentVolumeSource) DeepCopyInto(out *StorageOSPersistentVolumeSource) {
        *out = *in
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(ObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageOSPersistentVolumeSource.
func (in *StorageOSPersistentVolumeSource) DeepCopy() *StorageOSPersistentVolumeSource {
        if in == nil {
                return nil
        }
        out := new(StorageOSPersistentVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *StorageOSVolumeSource) DeepCopyInto(out *StorageOSVolumeSource) {
        *out = *in
        if in.SecretRef != nil {
                in, out := &in.SecretRef, &out.SecretRef
                *out = new(LocalObjectReference)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageOSVolumeSource.
func (in *StorageOSVolumeSource) DeepCopy() *StorageOSVolumeSource {
        if in == nil {
                return nil
        }
        out := new(StorageOSVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Sysctl) DeepCopyInto(out *Sysctl) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Sysctl.
func (in *Sysctl) DeepCopy() *Sysctl {
        if in == nil {
                return nil
        }
        out := new(Sysctl)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TCPSocketAction) DeepCopyInto(out *TCPSocketAction) {
        *out = *in
        out.Port = in.Port
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPSocketAction.
func (in *TCPSocketAction) DeepCopy() *TCPSocketAction {
        if in == nil {
                return nil
        }
        out := new(TCPSocketAction)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Taint) DeepCopyInto(out *Taint) {
        *out = *in
        if in.TimeAdded != nil {
                in, out := &in.TimeAdded, &out.TimeAdded
                *out = (*in).DeepCopy()
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Taint.
func (in *Taint) DeepCopy() *Taint {
        if in == nil {
                return nil
        }
        out := new(Taint)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Toleration) DeepCopyInto(out *Toleration) {
        *out = *in
        if in.TolerationSeconds != nil {
                in, out := &in.TolerationSeconds, &out.TolerationSeconds
                *out = new(int64)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Toleration.
func (in *Toleration) DeepCopy() *Toleration {
        if in == nil {
                return nil
        }
        out := new(Toleration)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TopologySelectorLabelRequirement) DeepCopyInto(out *TopologySelectorLabelRequirement) {
        *out = *in
        if in.Values != nil {
                in, out := &in.Values, &out.Values
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TopologySelectorLabelRequirement.
func (in *TopologySelectorLabelRequirement) DeepCopy() *TopologySelectorLabelRequirement {
        if in == nil {
                return nil
        }
        out := new(TopologySelectorLabelRequirement)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TopologySelectorTerm) DeepCopyInto(out *TopologySelectorTerm) {
        *out = *in
        if in.MatchLabelExpressions != nil {
                in, out := &in.MatchLabelExpressions, &out.MatchLabelExpressions
                *out = make([]TopologySelectorLabelRequirement, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TopologySelectorTerm.
func (in *TopologySelectorTerm) DeepCopy() *TopologySelectorTerm {
        if in == nil {
                return nil
        }
        out := new(TopologySelectorTerm)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TopologySpreadConstraint) DeepCopyInto(out *TopologySpreadConstraint) {
        *out = *in
        if in.LabelSelector != nil {
                in, out := &in.LabelSelector, &out.LabelSelector
                *out = new(v1.LabelSelector)
                (*in).DeepCopyInto(*out)
        }
        if in.MinDomains != nil {
                in, out := &in.MinDomains, &out.MinDomains
                *out = new(int32)
                **out = **in
        }
        if in.NodeAffinityPolicy != nil {
                in, out := &in.NodeAffinityPolicy, &out.NodeAffinityPolicy
                *out = new(NodeInclusionPolicy)
                **out = **in
        }
        if in.NodeTaintsPolicy != nil {
                in, out := &in.NodeTaintsPolicy, &out.NodeTaintsPolicy
                *out = new(NodeInclusionPolicy)
                **out = **in
        }
        if in.MatchLabelKeys != nil {
                in, out := &in.MatchLabelKeys, &out.MatchLabelKeys
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TopologySpreadConstraint.
func (in *TopologySpreadConstraint) DeepCopy() *TopologySpreadConstraint {
        if in == nil {
                return nil
        }
        out := new(TopologySpreadConstraint)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TypedLocalObjectReference) DeepCopyInto(out *TypedLocalObjectReference) {
        *out = *in
        if in.APIGroup != nil {
                in, out := &in.APIGroup, &out.APIGroup
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TypedLocalObjectReference.
func (in *TypedLocalObjectReference) DeepCopy() *TypedLocalObjectReference {
        if in == nil {
                return nil
        }
        out := new(TypedLocalObjectReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *TypedObjectReference) DeepCopyInto(out *TypedObjectReference) {
        *out = *in
        if in.APIGroup != nil {
                in, out := &in.APIGroup, &out.APIGroup
                *out = new(string)
                **out = **in
        }
        if in.Namespace != nil {
                in, out := &in.Namespace, &out.Namespace
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TypedObjectReference.
func (in *TypedObjectReference) DeepCopy() *TypedObjectReference {
        if in == nil {
                return nil
        }
        out := new(TypedObjectReference)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Volume) DeepCopyInto(out *Volume) {
        *out = *in
        in.VolumeSource.DeepCopyInto(&out.VolumeSource)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Volume.
func (in *Volume) DeepCopy() *Volume {
        if in == nil {
                return nil
        }
        out := new(Volume)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *VolumeDevice) DeepCopyInto(out *VolumeDevice) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeDevice.
func (in *VolumeDevice) DeepCopy() *VolumeDevice {
        if in == nil {
                return nil
        }
        out := new(VolumeDevice)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *VolumeMount) DeepCopyInto(out *VolumeMount) {
        *out = *in
        if in.RecursiveReadOnly != nil {
                in, out := &in.RecursiveReadOnly, &out.RecursiveReadOnly
                *out = new(RecursiveReadOnlyMode)
                **out = **in
        }
        if in.MountPropagation != nil {
                in, out := &in.MountPropagation, &out.MountPropagation
                *out = new(MountPropagationMode)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeMount.
func (in *VolumeMount) DeepCopy() *VolumeMount {
        if in == nil {
                return nil
        }
        out := new(VolumeMount)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *VolumeMountStatus) DeepCopyInto(out *VolumeMountStatus) {
        *out = *in
        if in.RecursiveReadOnly != nil {
                in, out := &in.RecursiveReadOnly, &out.RecursiveReadOnly
                *out = new(RecursiveReadOnlyMode)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeMountStatus.
func (in *VolumeMountStatus) DeepCopy() *VolumeMountStatus {
        if in == nil {
                return nil
        }
        out := new(VolumeMountStatus)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *VolumeNodeAffinity) DeepCopyInto(out *VolumeNodeAffinity) {
        *out = *in
        if in.Required != nil {
                in, out := &in.Required, &out.Required
                *out = new(NodeSelector)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeNodeAffinity.
func (in *VolumeNodeAffinity) DeepCopy() *VolumeNodeAffinity {
        if in == nil {
                return nil
        }
        out := new(VolumeNodeAffinity)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *VolumeProjection) DeepCopyInto(out *VolumeProjection) {
        *out = *in
        if in.Secret != nil {
                in, out := &in.Secret, &out.Secret
                *out = new(SecretProjection)
                (*in).DeepCopyInto(*out)
        }
        if in.DownwardAPI != nil {
                in, out := &in.DownwardAPI, &out.DownwardAPI
                *out = new(DownwardAPIProjection)
                (*in).DeepCopyInto(*out)
        }
        if in.ConfigMap != nil {
                in, out := &in.ConfigMap, &out.ConfigMap
                *out = new(ConfigMapProjection)
                (*in).DeepCopyInto(*out)
        }
        if in.ServiceAccountToken != nil {
                in, out := &in.ServiceAccountToken, &out.ServiceAccountToken
                *out = new(ServiceAccountTokenProjection)
                **out = **in
        }
        if in.ClusterTrustBundle != nil {
                in, out := &in.ClusterTrustBundle, &out.ClusterTrustBundle
                *out = new(ClusterTrustBundleProjection)
                (*in).DeepCopyInto(*out)
        }
        if in.PodCertificate != nil {
                in, out := &in.PodCertificate, &out.PodCertificate
                *out = new(PodCertificateProjection)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeProjection.
func (in *VolumeProjection) DeepCopy() *VolumeProjection {
        if in == nil {
                return nil
        }
        out := new(VolumeProjection)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *VolumeResourceRequirements) DeepCopyInto(out *VolumeResourceRequirements) {
        *out = *in
        if in.Limits != nil {
                in, out := &in.Limits, &out.Limits
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        if in.Requests != nil {
                in, out := &in.Requests, &out.Requests
                *out = make(ResourceList, len(*in))
                for key, val := range *in {
                        (*out)[key] = val.DeepCopy()
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeResourceRequirements.
func (in *VolumeResourceRequirements) DeepCopy() *VolumeResourceRequirements {
        if in == nil {
                return nil
        }
        out := new(VolumeResourceRequirements)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *VolumeSource) DeepCopyInto(out *VolumeSource) {
        *out = *in
        if in.HostPath != nil {
                in, out := &in.HostPath, &out.HostPath
                *out = new(HostPathVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.EmptyDir != nil {
                in, out := &in.EmptyDir, &out.EmptyDir
                *out = new(EmptyDirVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.GCEPersistentDisk != nil {
                in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk
                *out = new(GCEPersistentDiskVolumeSource)
                **out = **in
        }
        if in.AWSElasticBlockStore != nil {
                in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore
                *out = new(AWSElasticBlockStoreVolumeSource)
                **out = **in
        }
        if in.GitRepo != nil {
                in, out := &in.GitRepo, &out.GitRepo
                *out = new(GitRepoVolumeSource)
                **out = **in
        }
        if in.Secret != nil {
                in, out := &in.Secret, &out.Secret
                *out = new(SecretVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.NFS != nil {
                in, out := &in.NFS, &out.NFS
                *out = new(NFSVolumeSource)
                **out = **in
        }
        if in.ISCSI != nil {
                in, out := &in.ISCSI, &out.ISCSI
                *out = new(ISCSIVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Glusterfs != nil {
                in, out := &in.Glusterfs, &out.Glusterfs
                *out = new(GlusterfsVolumeSource)
                **out = **in
        }
        if in.PersistentVolumeClaim != nil {
                in, out := &in.PersistentVolumeClaim, &out.PersistentVolumeClaim
                *out = new(PersistentVolumeClaimVolumeSource)
                **out = **in
        }
        if in.RBD != nil {
                in, out := &in.RBD, &out.RBD
                *out = new(RBDVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Quobyte != nil {
                in, out := &in.Quobyte, &out.Quobyte
                *out = new(QuobyteVolumeSource)
                **out = **in
        }
        if in.FlexVolume != nil {
                in, out := &in.FlexVolume, &out.FlexVolume
                *out = new(FlexVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Cinder != nil {
                in, out := &in.Cinder, &out.Cinder
                *out = new(CinderVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.CephFS != nil {
                in, out := &in.CephFS, &out.CephFS
                *out = new(CephFSVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Flocker != nil {
                in, out := &in.Flocker, &out.Flocker
                *out = new(FlockerVolumeSource)
                **out = **in
        }
        if in.DownwardAPI != nil {
                in, out := &in.DownwardAPI, &out.DownwardAPI
                *out = new(DownwardAPIVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.FC != nil {
                in, out := &in.FC, &out.FC
                *out = new(FCVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.AzureFile != nil {
                in, out := &in.AzureFile, &out.AzureFile
                *out = new(AzureFileVolumeSource)
                **out = **in
        }
        if in.ConfigMap != nil {
                in, out := &in.ConfigMap, &out.ConfigMap
                *out = new(ConfigMapVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.VsphereVolume != nil {
                in, out := &in.VsphereVolume, &out.VsphereVolume
                *out = new(VsphereVirtualDiskVolumeSource)
                **out = **in
        }
        if in.AzureDisk != nil {
                in, out := &in.AzureDisk, &out.AzureDisk
                *out = new(AzureDiskVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.PhotonPersistentDisk != nil {
                in, out := &in.PhotonPersistentDisk, &out.PhotonPersistentDisk
                *out = new(PhotonPersistentDiskVolumeSource)
                **out = **in
        }
        if in.Projected != nil {
                in, out := &in.Projected, &out.Projected
                *out = new(ProjectedVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.PortworxVolume != nil {
                in, out := &in.PortworxVolume, &out.PortworxVolume
                *out = new(PortworxVolumeSource)
                **out = **in
        }
        if in.ScaleIO != nil {
                in, out := &in.ScaleIO, &out.ScaleIO
                *out = new(ScaleIOVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.StorageOS != nil {
                in, out := &in.StorageOS, &out.StorageOS
                *out = new(StorageOSVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.CSI != nil {
                in, out := &in.CSI, &out.CSI
                *out = new(CSIVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Ephemeral != nil {
                in, out := &in.Ephemeral, &out.Ephemeral
                *out = new(EphemeralVolumeSource)
                (*in).DeepCopyInto(*out)
        }
        if in.Image != nil {
                in, out := &in.Image, &out.Image
                *out = new(ImageVolumeSource)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VolumeSource.
func (in *VolumeSource) DeepCopy() *VolumeSource {
        if in == nil {
                return nil
        }
        out := new(VolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *VsphereVirtualDiskVolumeSource) DeepCopyInto(out *VsphereVirtualDiskVolumeSource) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new VsphereVirtualDiskVolumeSource.
func (in *VsphereVirtualDiskVolumeSource) DeepCopy() *VsphereVirtualDiskVolumeSource {
        if in == nil {
                return nil
        }
        out := new(VsphereVirtualDiskVolumeSource)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *WeightedPodAffinityTerm) DeepCopyInto(out *WeightedPodAffinityTerm) {
        *out = *in
        in.PodAffinityTerm.DeepCopyInto(&out.PodAffinityTerm)
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WeightedPodAffinityTerm.
func (in *WeightedPodAffinityTerm) DeepCopy() *WeightedPodAffinityTerm {
        if in == nil {
                return nil
        }
        out := new(WeightedPodAffinityTerm)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *WindowsSecurityContextOptions) DeepCopyInto(out *WindowsSecurityContextOptions) {
        *out = *in
        if in.GMSACredentialSpecName != nil {
                in, out := &in.GMSACredentialSpecName, &out.GMSACredentialSpecName
                *out = new(string)
                **out = **in
        }
        if in.GMSACredentialSpec != nil {
                in, out := &in.GMSACredentialSpec, &out.GMSACredentialSpec
                *out = new(string)
                **out = **in
        }
        if in.RunAsUserName != nil {
                in, out := &in.RunAsUserName, &out.RunAsUserName
                *out = new(string)
                **out = **in
        }
        if in.HostProcess != nil {
                in, out := &in.HostProcess, &out.HostProcess
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WindowsSecurityContextOptions.
func (in *WindowsSecurityContextOptions) DeepCopy() *WindowsSecurityContextOptions {
        if in == nil {
                return nil
        }
        out := new(WindowsSecurityContextOptions)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        "sigs.k8s.io/randfill"

        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
        api "k8s.io/kubernetes/pkg/apis/core"
        "k8s.io/kubernetes/pkg/apis/discovery"
)

// Funcs returns the fuzzer functions for the discovery api group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(obj *discovery.EndpointSlice, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again

                        addressTypes := []discovery.AddressType{discovery.AddressTypeIPv4, discovery.AddressTypeIPv6, discovery.AddressTypeFQDN}
                        obj.AddressType = addressTypes[c.Rand.Intn(len(addressTypes))]

                        for i, endpointPort := range obj.Ports {
                                if endpointPort.Name == nil {
                                        emptyStr := ""
                                        obj.Ports[i].Name = &emptyStr
                                }

                                if endpointPort.Protocol == nil {
                                        protos := []api.Protocol{api.ProtocolTCP, api.ProtocolUDP, api.ProtocolSCTP}
                                        obj.Ports[i].Protocol = &protos[c.Rand.Intn(len(protos))]
                                }
                        }
                },
        }
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

// Package install installs the discovery API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/discovery"
        v1 "k8s.io/kubernetes/pkg/apis/discovery/v1"
        "k8s.io/kubernetes/pkg/apis/discovery/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(discovery.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion))
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

package discovery

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name used in this package
const GroupName = "discovery.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder is the scheme builder with scheme init functions to run for this API package
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme is a global function that registers this API group & version to a scheme
        AddToScheme = SchemeBuilder.AddToScheme
)

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &EndpointSlice{},
                &EndpointSliceList{},
        )
        return nil
}

/*
Copyright 2021 The Kubernetes Authors.

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.
*/

package v1

import (
        v1 "k8s.io/api/core/v1"
        discoveryv1 "k8s.io/api/discovery/v1"
        "k8s.io/apimachinery/pkg/runtime"
)

var (
        defaultPortName = ""
        defaultProtocol = v1.ProtocolTCP
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_EndpointPort(obj *discoveryv1.EndpointPort) {
        if obj.Name == nil {
                obj.Name = &defaultPortName
        }

        if obj.Protocol == nil {
                obj.Protocol = &defaultProtocol
        }
}

/*
Copyright 2021 The Kubernetes Authors.

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.
*/

package v1

import (
        discoveryv1 "k8s.io/api/discovery/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name used in this package
const GroupName = "discovery.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &discoveryv1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        corev1 "k8s.io/api/core/v1"
        discoveryv1 "k8s.io/api/discovery/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        core "k8s.io/kubernetes/pkg/apis/core"
        discovery "k8s.io/kubernetes/pkg/apis/discovery"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*discoveryv1.Endpoint)(nil), (*discovery.Endpoint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Endpoint_To_discovery_Endpoint(a.(*discoveryv1.Endpoint), b.(*discovery.Endpoint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.Endpoint)(nil), (*discoveryv1.Endpoint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_Endpoint_To_v1_Endpoint(a.(*discovery.Endpoint), b.(*discoveryv1.Endpoint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1.EndpointConditions)(nil), (*discovery.EndpointConditions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointConditions_To_discovery_EndpointConditions(a.(*discoveryv1.EndpointConditions), b.(*discovery.EndpointConditions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointConditions)(nil), (*discoveryv1.EndpointConditions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointConditions_To_v1_EndpointConditions(a.(*discovery.EndpointConditions), b.(*discoveryv1.EndpointConditions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1.EndpointHints)(nil), (*discovery.EndpointHints)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointHints_To_discovery_EndpointHints(a.(*discoveryv1.EndpointHints), b.(*discovery.EndpointHints), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointHints)(nil), (*discoveryv1.EndpointHints)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointHints_To_v1_EndpointHints(a.(*discovery.EndpointHints), b.(*discoveryv1.EndpointHints), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1.EndpointPort)(nil), (*discovery.EndpointPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointPort_To_discovery_EndpointPort(a.(*discoveryv1.EndpointPort), b.(*discovery.EndpointPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointPort)(nil), (*discoveryv1.EndpointPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointPort_To_v1_EndpointPort(a.(*discovery.EndpointPort), b.(*discoveryv1.EndpointPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1.EndpointSlice)(nil), (*discovery.EndpointSlice)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointSlice_To_discovery_EndpointSlice(a.(*discoveryv1.EndpointSlice), b.(*discovery.EndpointSlice), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointSlice)(nil), (*discoveryv1.EndpointSlice)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointSlice_To_v1_EndpointSlice(a.(*discovery.EndpointSlice), b.(*discoveryv1.EndpointSlice), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1.EndpointSliceList)(nil), (*discovery.EndpointSliceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EndpointSliceList_To_discovery_EndpointSliceList(a.(*discoveryv1.EndpointSliceList), b.(*discovery.EndpointSliceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointSliceList)(nil), (*discoveryv1.EndpointSliceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointSliceList_To_v1_EndpointSliceList(a.(*discovery.EndpointSliceList), b.(*discoveryv1.EndpointSliceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1.ForNode)(nil), (*discovery.ForNode)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ForNode_To_discovery_ForNode(a.(*discoveryv1.ForNode), b.(*discovery.ForNode), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.ForNode)(nil), (*discoveryv1.ForNode)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_ForNode_To_v1_ForNode(a.(*discovery.ForNode), b.(*discoveryv1.ForNode), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1.ForZone)(nil), (*discovery.ForZone)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ForZone_To_discovery_ForZone(a.(*discoveryv1.ForZone), b.(*discovery.ForZone), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.ForZone)(nil), (*discoveryv1.ForZone)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_ForZone_To_v1_ForZone(a.(*discovery.ForZone), b.(*discoveryv1.ForZone), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_Endpoint_To_discovery_Endpoint(in *discoveryv1.Endpoint, out *discovery.Endpoint, s conversion.Scope) error {
        out.Addresses = *(*[]string)(unsafe.Pointer(&in.Addresses))
        if err := Convert_v1_EndpointConditions_To_discovery_EndpointConditions(&in.Conditions, &out.Conditions, s); err != nil {
                return err
        }
        out.Hostname = (*string)(unsafe.Pointer(in.Hostname))
        out.TargetRef = (*core.ObjectReference)(unsafe.Pointer(in.TargetRef))
        out.DeprecatedTopology = *(*map[string]string)(unsafe.Pointer(&in.DeprecatedTopology))
        out.NodeName = (*string)(unsafe.Pointer(in.NodeName))
        out.Zone = (*string)(unsafe.Pointer(in.Zone))
        out.Hints = (*discovery.EndpointHints)(unsafe.Pointer(in.Hints))
        return nil
}

// Convert_v1_Endpoint_To_discovery_Endpoint is an autogenerated conversion function.
func Convert_v1_Endpoint_To_discovery_Endpoint(in *discoveryv1.Endpoint, out *discovery.Endpoint, s conversion.Scope) error {
        return autoConvert_v1_Endpoint_To_discovery_Endpoint(in, out, s)
}

func autoConvert_discovery_Endpoint_To_v1_Endpoint(in *discovery.Endpoint, out *discoveryv1.Endpoint, s conversion.Scope) error {
        out.Addresses = *(*[]string)(unsafe.Pointer(&in.Addresses))
        if err := Convert_discovery_EndpointConditions_To_v1_EndpointConditions(&in.Conditions, &out.Conditions, s); err != nil {
                return err
        }
        out.Hostname = (*string)(unsafe.Pointer(in.Hostname))
        out.TargetRef = (*corev1.ObjectReference)(unsafe.Pointer(in.TargetRef))
        out.DeprecatedTopology = *(*map[string]string)(unsafe.Pointer(&in.DeprecatedTopology))
        out.NodeName = (*string)(unsafe.Pointer(in.NodeName))
        out.Zone = (*string)(unsafe.Pointer(in.Zone))
        out.Hints = (*discoveryv1.EndpointHints)(unsafe.Pointer(in.Hints))
        return nil
}

// Convert_discovery_Endpoint_To_v1_Endpoint is an autogenerated conversion function.
func Convert_discovery_Endpoint_To_v1_Endpoint(in *discovery.Endpoint, out *discoveryv1.Endpoint, s conversion.Scope) error {
        return autoConvert_discovery_Endpoint_To_v1_Endpoint(in, out, s)
}

func autoConvert_v1_EndpointConditions_To_discovery_EndpointConditions(in *discoveryv1.EndpointConditions, out *discovery.EndpointConditions, s conversion.Scope) error {
        out.Ready = (*bool)(unsafe.Pointer(in.Ready))
        out.Serving = (*bool)(unsafe.Pointer(in.Serving))
        out.Terminating = (*bool)(unsafe.Pointer(in.Terminating))
        return nil
}

// Convert_v1_EndpointConditions_To_discovery_EndpointConditions is an autogenerated conversion function.
func Convert_v1_EndpointConditions_To_discovery_EndpointConditions(in *discoveryv1.EndpointConditions, out *discovery.EndpointConditions, s conversion.Scope) error {
        return autoConvert_v1_EndpointConditions_To_discovery_EndpointConditions(in, out, s)
}

func autoConvert_discovery_EndpointConditions_To_v1_EndpointConditions(in *discovery.EndpointConditions, out *discoveryv1.EndpointConditions, s conversion.Scope) error {
        out.Ready = (*bool)(unsafe.Pointer(in.Ready))
        out.Serving = (*bool)(unsafe.Pointer(in.Serving))
        out.Terminating = (*bool)(unsafe.Pointer(in.Terminating))
        return nil
}

// Convert_discovery_EndpointConditions_To_v1_EndpointConditions is an autogenerated conversion function.
func Convert_discovery_EndpointConditions_To_v1_EndpointConditions(in *discovery.EndpointConditions, out *discoveryv1.EndpointConditions, s conversion.Scope) error {
        return autoConvert_discovery_EndpointConditions_To_v1_EndpointConditions(in, out, s)
}

func autoConvert_v1_EndpointHints_To_discovery_EndpointHints(in *discoveryv1.EndpointHints, out *discovery.EndpointHints, s conversion.Scope) error {
        out.ForZones = *(*[]discovery.ForZone)(unsafe.Pointer(&in.ForZones))
        out.ForNodes = *(*[]discovery.ForNode)(unsafe.Pointer(&in.ForNodes))
        return nil
}

// Convert_v1_EndpointHints_To_discovery_EndpointHints is an autogenerated conversion function.
func Convert_v1_EndpointHints_To_discovery_EndpointHints(in *discoveryv1.EndpointHints, out *discovery.EndpointHints, s conversion.Scope) error {
        return autoConvert_v1_EndpointHints_To_discovery_EndpointHints(in, out, s)
}

func autoConvert_discovery_EndpointHints_To_v1_EndpointHints(in *discovery.EndpointHints, out *discoveryv1.EndpointHints, s conversion.Scope) error {
        out.ForZones = *(*[]discoveryv1.ForZone)(unsafe.Pointer(&in.ForZones))
        out.ForNodes = *(*[]discoveryv1.ForNode)(unsafe.Pointer(&in.ForNodes))
        return nil
}

// Convert_discovery_EndpointHints_To_v1_EndpointHints is an autogenerated conversion function.
func Convert_discovery_EndpointHints_To_v1_EndpointHints(in *discovery.EndpointHints, out *discoveryv1.EndpointHints, s conversion.Scope) error {
        return autoConvert_discovery_EndpointHints_To_v1_EndpointHints(in, out, s)
}

func autoConvert_v1_EndpointPort_To_discovery_EndpointPort(in *discoveryv1.EndpointPort, out *discovery.EndpointPort, s conversion.Scope) error {
        out.Name = (*string)(unsafe.Pointer(in.Name))
        out.Protocol = (*core.Protocol)(unsafe.Pointer(in.Protocol))
        out.Port = (*int32)(unsafe.Pointer(in.Port))
        out.AppProtocol = (*string)(unsafe.Pointer(in.AppProtocol))
        return nil
}

// Convert_v1_EndpointPort_To_discovery_EndpointPort is an autogenerated conversion function.
func Convert_v1_EndpointPort_To_discovery_EndpointPort(in *discoveryv1.EndpointPort, out *discovery.EndpointPort, s conversion.Scope) error {
        return autoConvert_v1_EndpointPort_To_discovery_EndpointPort(in, out, s)
}

func autoConvert_discovery_EndpointPort_To_v1_EndpointPort(in *discovery.EndpointPort, out *discoveryv1.EndpointPort, s conversion.Scope) error {
        out.Name = (*string)(unsafe.Pointer(in.Name))
        out.Protocol = (*corev1.Protocol)(unsafe.Pointer(in.Protocol))
        out.Port = (*int32)(unsafe.Pointer(in.Port))
        out.AppProtocol = (*string)(unsafe.Pointer(in.AppProtocol))
        return nil
}

// Convert_discovery_EndpointPort_To_v1_EndpointPort is an autogenerated conversion function.
func Convert_discovery_EndpointPort_To_v1_EndpointPort(in *discovery.EndpointPort, out *discoveryv1.EndpointPort, s conversion.Scope) error {
        return autoConvert_discovery_EndpointPort_To_v1_EndpointPort(in, out, s)
}

func autoConvert_v1_EndpointSlice_To_discovery_EndpointSlice(in *discoveryv1.EndpointSlice, out *discovery.EndpointSlice, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.AddressType = discovery.AddressType(in.AddressType)
        out.Endpoints = *(*[]discovery.Endpoint)(unsafe.Pointer(&in.Endpoints))
        out.Ports = *(*[]discovery.EndpointPort)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_v1_EndpointSlice_To_discovery_EndpointSlice is an autogenerated conversion function.
func Convert_v1_EndpointSlice_To_discovery_EndpointSlice(in *discoveryv1.EndpointSlice, out *discovery.EndpointSlice, s conversion.Scope) error {
        return autoConvert_v1_EndpointSlice_To_discovery_EndpointSlice(in, out, s)
}

func autoConvert_discovery_EndpointSlice_To_v1_EndpointSlice(in *discovery.EndpointSlice, out *discoveryv1.EndpointSlice, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.AddressType = discoveryv1.AddressType(in.AddressType)
        out.Endpoints = *(*[]discoveryv1.Endpoint)(unsafe.Pointer(&in.Endpoints))
        out.Ports = *(*[]discoveryv1.EndpointPort)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_discovery_EndpointSlice_To_v1_EndpointSlice is an autogenerated conversion function.
func Convert_discovery_EndpointSlice_To_v1_EndpointSlice(in *discovery.EndpointSlice, out *discoveryv1.EndpointSlice, s conversion.Scope) error {
        return autoConvert_discovery_EndpointSlice_To_v1_EndpointSlice(in, out, s)
}

func autoConvert_v1_EndpointSliceList_To_discovery_EndpointSliceList(in *discoveryv1.EndpointSliceList, out *discovery.EndpointSliceList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]discovery.EndpointSlice)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_EndpointSliceList_To_discovery_EndpointSliceList is an autogenerated conversion function.
func Convert_v1_EndpointSliceList_To_discovery_EndpointSliceList(in *discoveryv1.EndpointSliceList, out *discovery.EndpointSliceList, s conversion.Scope) error {
        return autoConvert_v1_EndpointSliceList_To_discovery_EndpointSliceList(in, out, s)
}

func autoConvert_discovery_EndpointSliceList_To_v1_EndpointSliceList(in *discovery.EndpointSliceList, out *discoveryv1.EndpointSliceList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]discoveryv1.EndpointSlice)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_discovery_EndpointSliceList_To_v1_EndpointSliceList is an autogenerated conversion function.
func Convert_discovery_EndpointSliceList_To_v1_EndpointSliceList(in *discovery.EndpointSliceList, out *discoveryv1.EndpointSliceList, s conversion.Scope) error {
        return autoConvert_discovery_EndpointSliceList_To_v1_EndpointSliceList(in, out, s)
}

func autoConvert_v1_ForNode_To_discovery_ForNode(in *discoveryv1.ForNode, out *discovery.ForNode, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_v1_ForNode_To_discovery_ForNode is an autogenerated conversion function.
func Convert_v1_ForNode_To_discovery_ForNode(in *discoveryv1.ForNode, out *discovery.ForNode, s conversion.Scope) error {
        return autoConvert_v1_ForNode_To_discovery_ForNode(in, out, s)
}

func autoConvert_discovery_ForNode_To_v1_ForNode(in *discovery.ForNode, out *discoveryv1.ForNode, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_discovery_ForNode_To_v1_ForNode is an autogenerated conversion function.
func Convert_discovery_ForNode_To_v1_ForNode(in *discovery.ForNode, out *discoveryv1.ForNode, s conversion.Scope) error {
        return autoConvert_discovery_ForNode_To_v1_ForNode(in, out, s)
}

func autoConvert_v1_ForZone_To_discovery_ForZone(in *discoveryv1.ForZone, out *discovery.ForZone, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_v1_ForZone_To_discovery_ForZone is an autogenerated conversion function.
func Convert_v1_ForZone_To_discovery_ForZone(in *discoveryv1.ForZone, out *discovery.ForZone, s conversion.Scope) error {
        return autoConvert_v1_ForZone_To_discovery_ForZone(in, out, s)
}

func autoConvert_discovery_ForZone_To_v1_ForZone(in *discovery.ForZone, out *discoveryv1.ForZone, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_discovery_ForZone_To_v1_ForZone is an autogenerated conversion function.
func Convert_discovery_ForZone_To_v1_ForZone(in *discovery.ForZone, out *discoveryv1.ForZone, s conversion.Scope) error {
        return autoConvert_discovery_ForZone_To_v1_ForZone(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        discoveryv1 "k8s.io/api/discovery/v1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&discoveryv1.EndpointSlice{}, func(obj interface{}) { SetObjectDefaults_EndpointSlice(obj.(*discoveryv1.EndpointSlice)) })
        scheme.AddTypeDefaultingFunc(&discoveryv1.EndpointSliceList{}, func(obj interface{}) { SetObjectDefaults_EndpointSliceList(obj.(*discoveryv1.EndpointSliceList)) })
        return nil
}

func SetObjectDefaults_EndpointSlice(in *discoveryv1.EndpointSlice) {
        for i := range in.Ports {
                a := &in.Ports[i]
                SetDefaults_EndpointPort(a)
        }
}

func SetObjectDefaults_EndpointSliceList(in *discoveryv1.EndpointSliceList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_EndpointSlice(a)
        }
}

/*
Copyright 2021 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        corev1 "k8s.io/api/core/v1"
        "k8s.io/api/discovery/v1beta1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/kubernetes/pkg/apis/discovery"
)

func Convert_v1beta1_Endpoint_To_discovery_Endpoint(in *v1beta1.Endpoint, out *discovery.Endpoint, s conversion.Scope) error {
        if err := autoConvert_v1beta1_Endpoint_To_discovery_Endpoint(in, out, s); err != nil {
                return err
        }
        if in.Topology != nil {
                // Copy        Topology into Deprecated Topology
                out.DeprecatedTopology = make(map[string]string, len(in.Topology))
                for k, v := range in.Topology {
                        out.DeprecatedTopology[k] = v
                }

                // Move zone from the topology map into a field
                if zone, ok := in.Topology[corev1.LabelTopologyZone]; ok {
                        out.Zone = &zone
                        delete(out.DeprecatedTopology, corev1.LabelTopologyZone)
                }

                // Remove hostname from the topology map ONLY IF it is the same value as
                // nodeName.  This preserves the (rather odd) ability to have different
                // values for topology[hostname] and nodename in v1beta1, without showing
                // duplicate values in v1.
                if node, ok := in.Topology[corev1.LabelHostname]; ok {
                        if out.NodeName != nil && node == *out.NodeName {
                                delete(out.DeprecatedTopology, corev1.LabelHostname)
                        }
                }

                // If zone & hostname were the only field in the map or topology was empty
                // set DeprecatedTopology to nil
                if len(out.DeprecatedTopology) == 0 {
                        out.DeprecatedTopology = nil
                }
        }

        return nil
}

func Convert_discovery_Endpoint_To_v1beta1_Endpoint(in *discovery.Endpoint, out *v1beta1.Endpoint, s conversion.Scope) error {
        if err := autoConvert_discovery_Endpoint_To_v1beta1_Endpoint(in, out, s); err != nil {
                return err
        }

        // If no deprecated topology, zone or node field, no conversion is necessary
        if in.DeprecatedTopology == nil && in.Zone == nil && in.NodeName == nil {
                return nil
        }

        // Copy        Deprecated Topology into Topology
        out.Topology = make(map[string]string, len(in.DeprecatedTopology))
        for k, v := range in.DeprecatedTopology {
                out.Topology[k] = v
        }

        // Add zone field into the topology map
        if in.Zone != nil {
                out.Topology[corev1.LabelTopologyZone] = *in.Zone
        }

        // Add hostname into the topology map ONLY IF it is not already present.
        // This preserves the (rather odd) ability to have different values for
        // topology[hostname] and nodename in v1beta1.
        if in.NodeName != nil && out.Topology[corev1.LabelHostname] == "" {
                out.Topology[corev1.LabelHostname] = *in.NodeName
        }

        return nil
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        v1 "k8s.io/api/core/v1"
        discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
        "k8s.io/apimachinery/pkg/runtime"
)

var (
        defaultPortName = ""
        defaultProtocol = v1.ProtocolTCP
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_EndpointPort(obj *discoveryv1beta1.EndpointPort) {
        if obj.Name == nil {
                obj.Name = &defaultPortName
        }

        if obj.Protocol == nil {
                obj.Protocol = &defaultProtocol
        }
}

/*
Copyright 2019 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name used in this package
const GroupName = "discovery.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &discoveryv1beta1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        v1 "k8s.io/api/core/v1"
        discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        core "k8s.io/kubernetes/pkg/apis/core"
        discovery "k8s.io/kubernetes/pkg/apis/discovery"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*discoveryv1beta1.EndpointConditions)(nil), (*discovery.EndpointConditions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_EndpointConditions_To_discovery_EndpointConditions(a.(*discoveryv1beta1.EndpointConditions), b.(*discovery.EndpointConditions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointConditions)(nil), (*discoveryv1beta1.EndpointConditions)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointConditions_To_v1beta1_EndpointConditions(a.(*discovery.EndpointConditions), b.(*discoveryv1beta1.EndpointConditions), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1beta1.EndpointHints)(nil), (*discovery.EndpointHints)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_EndpointHints_To_discovery_EndpointHints(a.(*discoveryv1beta1.EndpointHints), b.(*discovery.EndpointHints), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointHints)(nil), (*discoveryv1beta1.EndpointHints)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointHints_To_v1beta1_EndpointHints(a.(*discovery.EndpointHints), b.(*discoveryv1beta1.EndpointHints), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1beta1.EndpointPort)(nil), (*discovery.EndpointPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_EndpointPort_To_discovery_EndpointPort(a.(*discoveryv1beta1.EndpointPort), b.(*discovery.EndpointPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointPort)(nil), (*discoveryv1beta1.EndpointPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointPort_To_v1beta1_EndpointPort(a.(*discovery.EndpointPort), b.(*discoveryv1beta1.EndpointPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1beta1.EndpointSlice)(nil), (*discovery.EndpointSlice)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_EndpointSlice_To_discovery_EndpointSlice(a.(*discoveryv1beta1.EndpointSlice), b.(*discovery.EndpointSlice), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointSlice)(nil), (*discoveryv1beta1.EndpointSlice)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointSlice_To_v1beta1_EndpointSlice(a.(*discovery.EndpointSlice), b.(*discoveryv1beta1.EndpointSlice), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1beta1.EndpointSliceList)(nil), (*discovery.EndpointSliceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_EndpointSliceList_To_discovery_EndpointSliceList(a.(*discoveryv1beta1.EndpointSliceList), b.(*discovery.EndpointSliceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.EndpointSliceList)(nil), (*discoveryv1beta1.EndpointSliceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_EndpointSliceList_To_v1beta1_EndpointSliceList(a.(*discovery.EndpointSliceList), b.(*discoveryv1beta1.EndpointSliceList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1beta1.ForNode)(nil), (*discovery.ForNode)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ForNode_To_discovery_ForNode(a.(*discoveryv1beta1.ForNode), b.(*discovery.ForNode), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.ForNode)(nil), (*discoveryv1beta1.ForNode)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_ForNode_To_v1beta1_ForNode(a.(*discovery.ForNode), b.(*discoveryv1beta1.ForNode), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discoveryv1beta1.ForZone)(nil), (*discovery.ForZone)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ForZone_To_discovery_ForZone(a.(*discoveryv1beta1.ForZone), b.(*discovery.ForZone), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*discovery.ForZone)(nil), (*discoveryv1beta1.ForZone)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_ForZone_To_v1beta1_ForZone(a.(*discovery.ForZone), b.(*discoveryv1beta1.ForZone), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*discovery.Endpoint)(nil), (*discoveryv1beta1.Endpoint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_discovery_Endpoint_To_v1beta1_Endpoint(a.(*discovery.Endpoint), b.(*discoveryv1beta1.Endpoint), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*discoveryv1beta1.Endpoint)(nil), (*discovery.Endpoint)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Endpoint_To_discovery_Endpoint(a.(*discoveryv1beta1.Endpoint), b.(*discovery.Endpoint), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_Endpoint_To_discovery_Endpoint(in *discoveryv1beta1.Endpoint, out *discovery.Endpoint, s conversion.Scope) error {
        out.Addresses = *(*[]string)(unsafe.Pointer(&in.Addresses))
        if err := Convert_v1beta1_EndpointConditions_To_discovery_EndpointConditions(&in.Conditions, &out.Conditions, s); err != nil {
                return err
        }
        out.Hostname = (*string)(unsafe.Pointer(in.Hostname))
        out.TargetRef = (*core.ObjectReference)(unsafe.Pointer(in.TargetRef))
        // WARNING: in.Topology requires manual conversion: does not exist in peer-type
        out.NodeName = (*string)(unsafe.Pointer(in.NodeName))
        out.Hints = (*discovery.EndpointHints)(unsafe.Pointer(in.Hints))
        return nil
}

func autoConvert_discovery_Endpoint_To_v1beta1_Endpoint(in *discovery.Endpoint, out *discoveryv1beta1.Endpoint, s conversion.Scope) error {
        out.Addresses = *(*[]string)(unsafe.Pointer(&in.Addresses))
        if err := Convert_discovery_EndpointConditions_To_v1beta1_EndpointConditions(&in.Conditions, &out.Conditions, s); err != nil {
                return err
        }
        out.Hostname = (*string)(unsafe.Pointer(in.Hostname))
        out.TargetRef = (*v1.ObjectReference)(unsafe.Pointer(in.TargetRef))
        // WARNING: in.DeprecatedTopology requires manual conversion: does not exist in peer-type
        out.NodeName = (*string)(unsafe.Pointer(in.NodeName))
        // WARNING: in.Zone requires manual conversion: does not exist in peer-type
        out.Hints = (*discoveryv1beta1.EndpointHints)(unsafe.Pointer(in.Hints))
        return nil
}

func autoConvert_v1beta1_EndpointConditions_To_discovery_EndpointConditions(in *discoveryv1beta1.EndpointConditions, out *discovery.EndpointConditions, s conversion.Scope) error {
        out.Ready = (*bool)(unsafe.Pointer(in.Ready))
        out.Serving = (*bool)(unsafe.Pointer(in.Serving))
        out.Terminating = (*bool)(unsafe.Pointer(in.Terminating))
        return nil
}

// Convert_v1beta1_EndpointConditions_To_discovery_EndpointConditions is an autogenerated conversion function.
func Convert_v1beta1_EndpointConditions_To_discovery_EndpointConditions(in *discoveryv1beta1.EndpointConditions, out *discovery.EndpointConditions, s conversion.Scope) error {
        return autoConvert_v1beta1_EndpointConditions_To_discovery_EndpointConditions(in, out, s)
}

func autoConvert_discovery_EndpointConditions_To_v1beta1_EndpointConditions(in *discovery.EndpointConditions, out *discoveryv1beta1.EndpointConditions, s conversion.Scope) error {
        out.Ready = (*bool)(unsafe.Pointer(in.Ready))
        out.Serving = (*bool)(unsafe.Pointer(in.Serving))
        out.Terminating = (*bool)(unsafe.Pointer(in.Terminating))
        return nil
}

// Convert_discovery_EndpointConditions_To_v1beta1_EndpointConditions is an autogenerated conversion function.
func Convert_discovery_EndpointConditions_To_v1beta1_EndpointConditions(in *discovery.EndpointConditions, out *discoveryv1beta1.EndpointConditions, s conversion.Scope) error {
        return autoConvert_discovery_EndpointConditions_To_v1beta1_EndpointConditions(in, out, s)
}

func autoConvert_v1beta1_EndpointHints_To_discovery_EndpointHints(in *discoveryv1beta1.EndpointHints, out *discovery.EndpointHints, s conversion.Scope) error {
        out.ForZones = *(*[]discovery.ForZone)(unsafe.Pointer(&in.ForZones))
        out.ForNodes = *(*[]discovery.ForNode)(unsafe.Pointer(&in.ForNodes))
        return nil
}

// Convert_v1beta1_EndpointHints_To_discovery_EndpointHints is an autogenerated conversion function.
func Convert_v1beta1_EndpointHints_To_discovery_EndpointHints(in *discoveryv1beta1.EndpointHints, out *discovery.EndpointHints, s conversion.Scope) error {
        return autoConvert_v1beta1_EndpointHints_To_discovery_EndpointHints(in, out, s)
}

func autoConvert_discovery_EndpointHints_To_v1beta1_EndpointHints(in *discovery.EndpointHints, out *discoveryv1beta1.EndpointHints, s conversion.Scope) error {
        out.ForZones = *(*[]discoveryv1beta1.ForZone)(unsafe.Pointer(&in.ForZones))
        out.ForNodes = *(*[]discoveryv1beta1.ForNode)(unsafe.Pointer(&in.ForNodes))
        return nil
}

// Convert_discovery_EndpointHints_To_v1beta1_EndpointHints is an autogenerated conversion function.
func Convert_discovery_EndpointHints_To_v1beta1_EndpointHints(in *discovery.EndpointHints, out *discoveryv1beta1.EndpointHints, s conversion.Scope) error {
        return autoConvert_discovery_EndpointHints_To_v1beta1_EndpointHints(in, out, s)
}

func autoConvert_v1beta1_EndpointPort_To_discovery_EndpointPort(in *discoveryv1beta1.EndpointPort, out *discovery.EndpointPort, s conversion.Scope) error {
        out.Name = (*string)(unsafe.Pointer(in.Name))
        out.Protocol = (*core.Protocol)(unsafe.Pointer(in.Protocol))
        out.Port = (*int32)(unsafe.Pointer(in.Port))
        out.AppProtocol = (*string)(unsafe.Pointer(in.AppProtocol))
        return nil
}

// Convert_v1beta1_EndpointPort_To_discovery_EndpointPort is an autogenerated conversion function.
func Convert_v1beta1_EndpointPort_To_discovery_EndpointPort(in *discoveryv1beta1.EndpointPort, out *discovery.EndpointPort, s conversion.Scope) error {
        return autoConvert_v1beta1_EndpointPort_To_discovery_EndpointPort(in, out, s)
}

func autoConvert_discovery_EndpointPort_To_v1beta1_EndpointPort(in *discovery.EndpointPort, out *discoveryv1beta1.EndpointPort, s conversion.Scope) error {
        out.Name = (*string)(unsafe.Pointer(in.Name))
        out.Protocol = (*v1.Protocol)(unsafe.Pointer(in.Protocol))
        out.Port = (*int32)(unsafe.Pointer(in.Port))
        out.AppProtocol = (*string)(unsafe.Pointer(in.AppProtocol))
        return nil
}

// Convert_discovery_EndpointPort_To_v1beta1_EndpointPort is an autogenerated conversion function.
func Convert_discovery_EndpointPort_To_v1beta1_EndpointPort(in *discovery.EndpointPort, out *discoveryv1beta1.EndpointPort, s conversion.Scope) error {
        return autoConvert_discovery_EndpointPort_To_v1beta1_EndpointPort(in, out, s)
}

func autoConvert_v1beta1_EndpointSlice_To_discovery_EndpointSlice(in *discoveryv1beta1.EndpointSlice, out *discovery.EndpointSlice, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.AddressType = discovery.AddressType(in.AddressType)
        if in.Endpoints != nil {
                in, out := &in.Endpoints, &out.Endpoints
                *out = make([]discovery.Endpoint, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_Endpoint_To_discovery_Endpoint(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Endpoints = nil
        }
        out.Ports = *(*[]discovery.EndpointPort)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_v1beta1_EndpointSlice_To_discovery_EndpointSlice is an autogenerated conversion function.
func Convert_v1beta1_EndpointSlice_To_discovery_EndpointSlice(in *discoveryv1beta1.EndpointSlice, out *discovery.EndpointSlice, s conversion.Scope) error {
        return autoConvert_v1beta1_EndpointSlice_To_discovery_EndpointSlice(in, out, s)
}

func autoConvert_discovery_EndpointSlice_To_v1beta1_EndpointSlice(in *discovery.EndpointSlice, out *discoveryv1beta1.EndpointSlice, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.AddressType = discoveryv1beta1.AddressType(in.AddressType)
        if in.Endpoints != nil {
                in, out := &in.Endpoints, &out.Endpoints
                *out = make([]discoveryv1beta1.Endpoint, len(*in))
                for i := range *in {
                        if err := Convert_discovery_Endpoint_To_v1beta1_Endpoint(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Endpoints = nil
        }
        out.Ports = *(*[]discoveryv1beta1.EndpointPort)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_discovery_EndpointSlice_To_v1beta1_EndpointSlice is an autogenerated conversion function.
func Convert_discovery_EndpointSlice_To_v1beta1_EndpointSlice(in *discovery.EndpointSlice, out *discoveryv1beta1.EndpointSlice, s conversion.Scope) error {
        return autoConvert_discovery_EndpointSlice_To_v1beta1_EndpointSlice(in, out, s)
}

func autoConvert_v1beta1_EndpointSliceList_To_discovery_EndpointSliceList(in *discoveryv1beta1.EndpointSliceList, out *discovery.EndpointSliceList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]discovery.EndpointSlice, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_EndpointSlice_To_discovery_EndpointSlice(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_EndpointSliceList_To_discovery_EndpointSliceList is an autogenerated conversion function.
func Convert_v1beta1_EndpointSliceList_To_discovery_EndpointSliceList(in *discoveryv1beta1.EndpointSliceList, out *discovery.EndpointSliceList, s conversion.Scope) error {
        return autoConvert_v1beta1_EndpointSliceList_To_discovery_EndpointSliceList(in, out, s)
}

func autoConvert_discovery_EndpointSliceList_To_v1beta1_EndpointSliceList(in *discovery.EndpointSliceList, out *discoveryv1beta1.EndpointSliceList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]discoveryv1beta1.EndpointSlice, len(*in))
                for i := range *in {
                        if err := Convert_discovery_EndpointSlice_To_v1beta1_EndpointSlice(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_discovery_EndpointSliceList_To_v1beta1_EndpointSliceList is an autogenerated conversion function.
func Convert_discovery_EndpointSliceList_To_v1beta1_EndpointSliceList(in *discovery.EndpointSliceList, out *discoveryv1beta1.EndpointSliceList, s conversion.Scope) error {
        return autoConvert_discovery_EndpointSliceList_To_v1beta1_EndpointSliceList(in, out, s)
}

func autoConvert_v1beta1_ForNode_To_discovery_ForNode(in *discoveryv1beta1.ForNode, out *discovery.ForNode, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_v1beta1_ForNode_To_discovery_ForNode is an autogenerated conversion function.
func Convert_v1beta1_ForNode_To_discovery_ForNode(in *discoveryv1beta1.ForNode, out *discovery.ForNode, s conversion.Scope) error {
        return autoConvert_v1beta1_ForNode_To_discovery_ForNode(in, out, s)
}

func autoConvert_discovery_ForNode_To_v1beta1_ForNode(in *discovery.ForNode, out *discoveryv1beta1.ForNode, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_discovery_ForNode_To_v1beta1_ForNode is an autogenerated conversion function.
func Convert_discovery_ForNode_To_v1beta1_ForNode(in *discovery.ForNode, out *discoveryv1beta1.ForNode, s conversion.Scope) error {
        return autoConvert_discovery_ForNode_To_v1beta1_ForNode(in, out, s)
}

func autoConvert_v1beta1_ForZone_To_discovery_ForZone(in *discoveryv1beta1.ForZone, out *discovery.ForZone, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_v1beta1_ForZone_To_discovery_ForZone is an autogenerated conversion function.
func Convert_v1beta1_ForZone_To_discovery_ForZone(in *discoveryv1beta1.ForZone, out *discovery.ForZone, s conversion.Scope) error {
        return autoConvert_v1beta1_ForZone_To_discovery_ForZone(in, out, s)
}

func autoConvert_discovery_ForZone_To_v1beta1_ForZone(in *discovery.ForZone, out *discoveryv1beta1.ForZone, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_discovery_ForZone_To_v1beta1_ForZone is an autogenerated conversion function.
func Convert_discovery_ForZone_To_v1beta1_ForZone(in *discovery.ForZone, out *discoveryv1beta1.ForZone, s conversion.Scope) error {
        return autoConvert_discovery_ForZone_To_v1beta1_ForZone(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        discoveryv1beta1 "k8s.io/api/discovery/v1beta1"
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&discoveryv1beta1.EndpointSlice{}, func(obj interface{}) { SetObjectDefaults_EndpointSlice(obj.(*discoveryv1beta1.EndpointSlice)) })
        scheme.AddTypeDefaultingFunc(&discoveryv1beta1.EndpointSliceList{}, func(obj interface{}) { SetObjectDefaults_EndpointSliceList(obj.(*discoveryv1beta1.EndpointSliceList)) })
        return nil
}

func SetObjectDefaults_EndpointSlice(in *discoveryv1beta1.EndpointSlice) {
        for i := range in.Ports {
                a := &in.Ports[i]
                SetDefaults_EndpointPort(a)
        }
}

func SetObjectDefaults_EndpointSliceList(in *discoveryv1beta1.EndpointSliceList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_EndpointSlice(a)
        }
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 deepcopy-gen. DO NOT EDIT.

package discovery

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
        core "k8s.io/kubernetes/pkg/apis/core"
)

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Endpoint) DeepCopyInto(out *Endpoint) {
        *out = *in
        if in.Addresses != nil {
                in, out := &in.Addresses, &out.Addresses
                *out = make([]string, len(*in))
                copy(*out, *in)
        }
        in.Conditions.DeepCopyInto(&out.Conditions)
        if in.Hostname != nil {
                in, out := &in.Hostname, &out.Hostname
                *out = new(string)
                **out = **in
        }
        if in.TargetRef != nil {
                in, out := &in.TargetRef, &out.TargetRef
                *out = new(core.ObjectReference)
                **out = **in
        }
        if in.DeprecatedTopology != nil {
                in, out := &in.DeprecatedTopology, &out.DeprecatedTopology
                *out = make(map[string]string, len(*in))
                for key, val := range *in {
                        (*out)[key] = val
                }
        }
        if in.NodeName != nil {
                in, out := &in.NodeName, &out.NodeName
                *out = new(string)
                **out = **in
        }
        if in.Zone != nil {
                in, out := &in.Zone, &out.Zone
                *out = new(string)
                **out = **in
        }
        if in.Hints != nil {
                in, out := &in.Hints, &out.Hints
                *out = new(EndpointHints)
                (*in).DeepCopyInto(*out)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Endpoint.
func (in *Endpoint) DeepCopy() *Endpoint {
        if in == nil {
                return nil
        }
        out := new(Endpoint)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointConditions) DeepCopyInto(out *EndpointConditions) {
        *out = *in
        if in.Ready != nil {
                in, out := &in.Ready, &out.Ready
                *out = new(bool)
                **out = **in
        }
        if in.Serving != nil {
                in, out := &in.Serving, &out.Serving
                *out = new(bool)
                **out = **in
        }
        if in.Terminating != nil {
                in, out := &in.Terminating, &out.Terminating
                *out = new(bool)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointConditions.
func (in *EndpointConditions) DeepCopy() *EndpointConditions {
        if in == nil {
                return nil
        }
        out := new(EndpointConditions)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointHints) DeepCopyInto(out *EndpointHints) {
        *out = *in
        if in.ForZones != nil {
                in, out := &in.ForZones, &out.ForZones
                *out = make([]ForZone, len(*in))
                copy(*out, *in)
        }
        if in.ForNodes != nil {
                in, out := &in.ForNodes, &out.ForNodes
                *out = make([]ForNode, len(*in))
                copy(*out, *in)
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointHints.
func (in *EndpointHints) DeepCopy() *EndpointHints {
        if in == nil {
                return nil
        }
        out := new(EndpointHints)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointPort) DeepCopyInto(out *EndpointPort) {
        *out = *in
        if in.Name != nil {
                in, out := &in.Name, &out.Name
                *out = new(string)
                **out = **in
        }
        if in.Protocol != nil {
                in, out := &in.Protocol, &out.Protocol
                *out = new(core.Protocol)
                **out = **in
        }
        if in.Port != nil {
                in, out := &in.Port, &out.Port
                *out = new(int32)
                **out = **in
        }
        if in.AppProtocol != nil {
                in, out := &in.AppProtocol, &out.AppProtocol
                *out = new(string)
                **out = **in
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointPort.
func (in *EndpointPort) DeepCopy() *EndpointPort {
        if in == nil {
                return nil
        }
        out := new(EndpointPort)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointSlice) DeepCopyInto(out *EndpointSlice) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
        if in.Endpoints != nil {
                in, out := &in.Endpoints, &out.Endpoints
                *out = make([]Endpoint, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        if in.Ports != nil {
                in, out := &in.Ports, &out.Ports
                *out = make([]EndpointPort, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointSlice.
func (in *EndpointSlice) DeepCopy() *EndpointSlice {
        if in == nil {
                return nil
        }
        out := new(EndpointSlice)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *EndpointSlice) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *EndpointSliceList) DeepCopyInto(out *EndpointSliceList) {
        *out = *in
        out.TypeMeta = in.TypeMeta
        in.ListMeta.DeepCopyInto(&out.ListMeta)
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]EndpointSlice, len(*in))
                for i := range *in {
                        (*in)[i].DeepCopyInto(&(*out)[i])
                }
        }
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointSliceList.
func (in *EndpointSliceList) DeepCopy() *EndpointSliceList {
        if in == nil {
                return nil
        }
        out := new(EndpointSliceList)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
func (in *EndpointSliceList) DeepCopyObject() runtime.Object {
        if c := in.DeepCopy(); c != nil {
                return c
        }
        return nil
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ForNode) DeepCopyInto(out *ForNode) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ForNode.
func (in *ForNode) DeepCopy() *ForNode {
        if in == nil {
                return nil
        }
        out := new(ForNode)
        in.DeepCopyInto(out)
        return out
}

// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ForZone) DeepCopyInto(out *ForZone) {
        *out = *in
        return
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ForZone.
func (in *ForZone) DeepCopy() *ForZone {
        if in == nil {
                return nil
        }
        out := new(ForZone)
        in.DeepCopyInto(out)
        return out
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

// Package install installs the events API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/events"
        "k8s.io/kubernetes/pkg/apis/events/v1"
        "k8s.io/kubernetes/pkg/apis/events/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(events.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(v1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion))
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package events

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
        "k8s.io/kubernetes/pkg/apis/core"
)

// GroupName is the group name use in this package
const GroupName = "events.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder points to a list of functions added to Scheme.
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme applies all the stored functions to the scheme.
        AddToScheme = SchemeBuilder.AddToScheme
)

func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &core.Event{},
                &core.EventList{},
        )
        return nil
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package v1

import (
        "fmt"

        v1 "k8s.io/api/events/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/runtime"
        k8s_api "k8s.io/kubernetes/pkg/apis/core"
        k8s_api_v1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

func Convert_v1_Event_To_core_Event(in *v1.Event, out *k8s_api.Event, s conversion.Scope) error {
        if err := autoConvert_v1_Event_To_core_Event(in, out, s); err != nil {
                return err
        }
        if err := k8s_api_v1.Convert_v1_ObjectReference_To_core_ObjectReference(&in.Regarding, &out.InvolvedObject, s); err != nil {
                return err
        }
        if err := k8s_api_v1.Convert_v1_EventSource_To_core_EventSource(&in.DeprecatedSource, &out.Source, s); err != nil {
                return err
        }
        out.Message = in.Note
        out.FirstTimestamp = in.DeprecatedFirstTimestamp
        out.LastTimestamp = in.DeprecatedLastTimestamp
        out.Count = in.DeprecatedCount
        return nil
}

func Convert_core_Event_To_v1_Event(in *k8s_api.Event, out *v1.Event, s conversion.Scope) error {
        if err := autoConvert_core_Event_To_v1_Event(in, out, s); err != nil {
                return err
        }
        if err := k8s_api_v1.Convert_core_ObjectReference_To_v1_ObjectReference(&in.InvolvedObject, &out.Regarding, s); err != nil {
                return err
        }
        if err := k8s_api_v1.Convert_core_EventSource_To_v1_EventSource(&in.Source, &out.DeprecatedSource, s); err != nil {
                return err
        }
        out.Note = in.Message
        out.DeprecatedFirstTimestamp = in.FirstTimestamp
        out.DeprecatedLastTimestamp = in.LastTimestamp
        out.DeprecatedCount = in.Count
        return nil
}

func AddFieldLabelConversionsForEvent(scheme *runtime.Scheme) error {
        mapping := map[string]string{
                "reason":                    "reason",
                "regarding.kind":            "involvedObject.kind",            // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.namespace":       "involvedObject.namespace",       // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.name":            "involvedObject.name",            // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.uid":             "involvedObject.uid",             // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.apiVersion":      "involvedObject.apiVersion",      // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.resourceVersion": "involvedObject.resourceVersion", // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.fieldPath":       "involvedObject.fieldPath",       // map events.k8s.io field to fieldset returned by ToSelectableFields
                "reportingController":       "reportingComponent",             // map events.k8s.io field to fieldset returned by ToSelectableFields
                "type":                      "type",
                "metadata.namespace":        "metadata.namespace",
                "metadata.name":             "metadata.name",
        }
        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Event"),
                func(label, value string) (string, string, error) {
                        mappedLabel, ok := mapping[label]
                        if !ok {
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                        return mappedLabel, value, nil
                },
        )
}

/*
Copyright 2020 The Kubernetes Authors.

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.
*/

package v1

import (
        eventsv1 "k8s.io/api/events/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "events.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &eventsv1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(RegisterDefaults, AddFieldLabelConversionsForEvent)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        corev1 "k8s.io/api/core/v1"
        eventsv1 "k8s.io/api/events/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*eventsv1.EventList)(nil), (*core.EventList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EventList_To_core_EventList(a.(*eventsv1.EventList), b.(*core.EventList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EventList)(nil), (*eventsv1.EventList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EventList_To_v1_EventList(a.(*core.EventList), b.(*eventsv1.EventList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*eventsv1.EventSeries)(nil), (*core.EventSeries)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_EventSeries_To_core_EventSeries(a.(*eventsv1.EventSeries), b.(*core.EventSeries), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EventSeries)(nil), (*eventsv1.EventSeries)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EventSeries_To_v1_EventSeries(a.(*core.EventSeries), b.(*eventsv1.EventSeries), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.Event)(nil), (*eventsv1.Event)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Event_To_v1_Event(a.(*core.Event), b.(*eventsv1.Event), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*eventsv1.Event)(nil), (*core.Event)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Event_To_core_Event(a.(*eventsv1.Event), b.(*core.Event), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_Event_To_core_Event(in *eventsv1.Event, out *core.Event, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.EventTime = in.EventTime
        out.Series = (*core.EventSeries)(unsafe.Pointer(in.Series))
        out.ReportingController = in.ReportingController
        out.ReportingInstance = in.ReportingInstance
        out.Action = in.Action
        out.Reason = in.Reason
        // WARNING: in.Regarding requires manual conversion: does not exist in peer-type
        out.Related = (*core.ObjectReference)(unsafe.Pointer(in.Related))
        // WARNING: in.Note requires manual conversion: does not exist in peer-type
        out.Type = in.Type
        // WARNING: in.DeprecatedSource requires manual conversion: does not exist in peer-type
        // WARNING: in.DeprecatedFirstTimestamp requires manual conversion: does not exist in peer-type
        // WARNING: in.DeprecatedLastTimestamp requires manual conversion: does not exist in peer-type
        // WARNING: in.DeprecatedCount requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_core_Event_To_v1_Event(in *core.Event, out *eventsv1.Event, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        // WARNING: in.InvolvedObject requires manual conversion: does not exist in peer-type
        out.Reason = in.Reason
        // WARNING: in.Message requires manual conversion: does not exist in peer-type
        // WARNING: in.Source requires manual conversion: does not exist in peer-type
        // WARNING: in.FirstTimestamp requires manual conversion: does not exist in peer-type
        // WARNING: in.LastTimestamp requires manual conversion: does not exist in peer-type
        // WARNING: in.Count requires manual conversion: does not exist in peer-type
        out.Type = in.Type
        out.EventTime = in.EventTime
        out.Series = (*eventsv1.EventSeries)(unsafe.Pointer(in.Series))
        out.Action = in.Action
        out.Related = (*corev1.ObjectReference)(unsafe.Pointer(in.Related))
        out.ReportingController = in.ReportingController
        out.ReportingInstance = in.ReportingInstance
        return nil
}

func autoConvert_v1_EventList_To_core_EventList(in *eventsv1.EventList, out *core.EventList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.Event, len(*in))
                for i := range *in {
                        if err := Convert_v1_Event_To_core_Event(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1_EventList_To_core_EventList is an autogenerated conversion function.
func Convert_v1_EventList_To_core_EventList(in *eventsv1.EventList, out *core.EventList, s conversion.Scope) error {
        return autoConvert_v1_EventList_To_core_EventList(in, out, s)
}

func autoConvert_core_EventList_To_v1_EventList(in *core.EventList, out *eventsv1.EventList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]eventsv1.Event, len(*in))
                for i := range *in {
                        if err := Convert_core_Event_To_v1_Event(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_EventList_To_v1_EventList is an autogenerated conversion function.
func Convert_core_EventList_To_v1_EventList(in *core.EventList, out *eventsv1.EventList, s conversion.Scope) error {
        return autoConvert_core_EventList_To_v1_EventList(in, out, s)
}

func autoConvert_v1_EventSeries_To_core_EventSeries(in *eventsv1.EventSeries, out *core.EventSeries, s conversion.Scope) error {
        out.Count = in.Count
        out.LastObservedTime = in.LastObservedTime
        return nil
}

// Convert_v1_EventSeries_To_core_EventSeries is an autogenerated conversion function.
func Convert_v1_EventSeries_To_core_EventSeries(in *eventsv1.EventSeries, out *core.EventSeries, s conversion.Scope) error {
        return autoConvert_v1_EventSeries_To_core_EventSeries(in, out, s)
}

func autoConvert_core_EventSeries_To_v1_EventSeries(in *core.EventSeries, out *eventsv1.EventSeries, s conversion.Scope) error {
        out.Count = in.Count
        out.LastObservedTime = in.LastObservedTime
        return nil
}

// Convert_core_EventSeries_To_v1_EventSeries is an autogenerated conversion function.
func Convert_core_EventSeries_To_v1_EventSeries(in *core.EventSeries, out *eventsv1.EventSeries, s conversion.Scope) error {
        return autoConvert_core_EventSeries_To_v1_EventSeries(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "fmt"

        v1beta1 "k8s.io/api/events/v1beta1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/runtime"
        k8s_api "k8s.io/kubernetes/pkg/apis/core"
        k8s_api_v1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

func Convert_v1beta1_Event_To_core_Event(in *v1beta1.Event, out *k8s_api.Event, s conversion.Scope) error {
        if err := autoConvert_v1beta1_Event_To_core_Event(in, out, s); err != nil {
                return err
        }
        if err := k8s_api_v1.Convert_v1_ObjectReference_To_core_ObjectReference(&in.Regarding, &out.InvolvedObject, s); err != nil {
                return err
        }
        if err := k8s_api_v1.Convert_v1_EventSource_To_core_EventSource(&in.DeprecatedSource, &out.Source, s); err != nil {
                return err
        }
        out.Message = in.Note
        out.FirstTimestamp = in.DeprecatedFirstTimestamp
        out.LastTimestamp = in.DeprecatedLastTimestamp
        out.Count = in.DeprecatedCount
        return nil
}

func Convert_core_Event_To_v1beta1_Event(in *k8s_api.Event, out *v1beta1.Event, s conversion.Scope) error {
        if err := autoConvert_core_Event_To_v1beta1_Event(in, out, s); err != nil {
                return err
        }
        if err := k8s_api_v1.Convert_core_ObjectReference_To_v1_ObjectReference(&in.InvolvedObject, &out.Regarding, s); err != nil {
                return err
        }
        if err := k8s_api_v1.Convert_core_EventSource_To_v1_EventSource(&in.Source, &out.DeprecatedSource, s); err != nil {
                return err
        }
        out.Note = in.Message
        out.DeprecatedFirstTimestamp = in.FirstTimestamp
        out.DeprecatedLastTimestamp = in.LastTimestamp
        out.DeprecatedCount = in.Count
        return nil
}

func AddFieldLabelConversionsForEvent(scheme *runtime.Scheme) error {
        mapping := map[string]string{
                "reason":                    "reason",
                "regarding.kind":            "involvedObject.kind",            // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.namespace":       "involvedObject.namespace",       // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.name":            "involvedObject.name",            // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.uid":             "involvedObject.uid",             // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.apiVersion":      "involvedObject.apiVersion",      // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.resourceVersion": "involvedObject.resourceVersion", // map events.k8s.io field to fieldset returned by ToSelectableFields
                "regarding.fieldPath":       "involvedObject.fieldPath",       // map events.k8s.io field to fieldset returned by ToSelectableFields
                "reportingController":       "reportingComponent",             // map events.k8s.io field to fieldset returned by ToSelectableFields
                "type":                      "type",
                "metadata.namespace":        "metadata.namespace",
                "metadata.name":             "metadata.name",
        }
        return scheme.AddFieldLabelConversionFunc(SchemeGroupVersion.WithKind("Event"),
                func(label, value string) (string, string, error) {
                        mappedLabel, ok := mapping[label]
                        if !ok {
                                return "", "", fmt.Errorf("field label not supported: %s", label)
                        }
                        return mappedLabel, value, nil
                },
        )
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        eventsv1beta1 "k8s.io/api/events/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "events.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &eventsv1beta1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(RegisterDefaults, AddFieldLabelConversionsForEvent)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        v1 "k8s.io/api/core/v1"
        eventsv1beta1 "k8s.io/api/events/v1beta1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        core "k8s.io/kubernetes/pkg/apis/core"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*eventsv1beta1.EventList)(nil), (*core.EventList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_EventList_To_core_EventList(a.(*eventsv1beta1.EventList), b.(*core.EventList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EventList)(nil), (*eventsv1beta1.EventList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EventList_To_v1beta1_EventList(a.(*core.EventList), b.(*eventsv1beta1.EventList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*eventsv1beta1.EventSeries)(nil), (*core.EventSeries)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_EventSeries_To_core_EventSeries(a.(*eventsv1beta1.EventSeries), b.(*core.EventSeries), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*core.EventSeries)(nil), (*eventsv1beta1.EventSeries)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_EventSeries_To_v1beta1_EventSeries(a.(*core.EventSeries), b.(*eventsv1beta1.EventSeries), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*core.Event)(nil), (*eventsv1beta1.Event)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_core_Event_To_v1beta1_Event(a.(*core.Event), b.(*eventsv1beta1.Event), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*eventsv1beta1.Event)(nil), (*core.Event)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Event_To_core_Event(a.(*eventsv1beta1.Event), b.(*core.Event), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_Event_To_core_Event(in *eventsv1beta1.Event, out *core.Event, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        out.EventTime = in.EventTime
        out.Series = (*core.EventSeries)(unsafe.Pointer(in.Series))
        out.ReportingController = in.ReportingController
        out.ReportingInstance = in.ReportingInstance
        out.Action = in.Action
        out.Reason = in.Reason
        // WARNING: in.Regarding requires manual conversion: does not exist in peer-type
        out.Related = (*core.ObjectReference)(unsafe.Pointer(in.Related))
        // WARNING: in.Note requires manual conversion: does not exist in peer-type
        out.Type = in.Type
        // WARNING: in.DeprecatedSource requires manual conversion: does not exist in peer-type
        // WARNING: in.DeprecatedFirstTimestamp requires manual conversion: does not exist in peer-type
        // WARNING: in.DeprecatedLastTimestamp requires manual conversion: does not exist in peer-type
        // WARNING: in.DeprecatedCount requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_core_Event_To_v1beta1_Event(in *core.Event, out *eventsv1beta1.Event, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        // WARNING: in.InvolvedObject requires manual conversion: does not exist in peer-type
        out.Reason = in.Reason
        // WARNING: in.Message requires manual conversion: does not exist in peer-type
        // WARNING: in.Source requires manual conversion: does not exist in peer-type
        // WARNING: in.FirstTimestamp requires manual conversion: does not exist in peer-type
        // WARNING: in.LastTimestamp requires manual conversion: does not exist in peer-type
        // WARNING: in.Count requires manual conversion: does not exist in peer-type
        out.Type = in.Type
        out.EventTime = in.EventTime
        out.Series = (*eventsv1beta1.EventSeries)(unsafe.Pointer(in.Series))
        out.Action = in.Action
        out.Related = (*v1.ObjectReference)(unsafe.Pointer(in.Related))
        out.ReportingController = in.ReportingController
        out.ReportingInstance = in.ReportingInstance
        return nil
}

func autoConvert_v1beta1_EventList_To_core_EventList(in *eventsv1beta1.EventList, out *core.EventList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]core.Event, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_Event_To_core_Event(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_EventList_To_core_EventList is an autogenerated conversion function.
func Convert_v1beta1_EventList_To_core_EventList(in *eventsv1beta1.EventList, out *core.EventList, s conversion.Scope) error {
        return autoConvert_v1beta1_EventList_To_core_EventList(in, out, s)
}

func autoConvert_core_EventList_To_v1beta1_EventList(in *core.EventList, out *eventsv1beta1.EventList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]eventsv1beta1.Event, len(*in))
                for i := range *in {
                        if err := Convert_core_Event_To_v1beta1_Event(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_core_EventList_To_v1beta1_EventList is an autogenerated conversion function.
func Convert_core_EventList_To_v1beta1_EventList(in *core.EventList, out *eventsv1beta1.EventList, s conversion.Scope) error {
        return autoConvert_core_EventList_To_v1beta1_EventList(in, out, s)
}

func autoConvert_v1beta1_EventSeries_To_core_EventSeries(in *eventsv1beta1.EventSeries, out *core.EventSeries, s conversion.Scope) error {
        out.Count = in.Count
        out.LastObservedTime = in.LastObservedTime
        return nil
}

// Convert_v1beta1_EventSeries_To_core_EventSeries is an autogenerated conversion function.
func Convert_v1beta1_EventSeries_To_core_EventSeries(in *eventsv1beta1.EventSeries, out *core.EventSeries, s conversion.Scope) error {
        return autoConvert_v1beta1_EventSeries_To_core_EventSeries(in, out, s)
}

func autoConvert_core_EventSeries_To_v1beta1_EventSeries(in *core.EventSeries, out *eventsv1beta1.EventSeries, s conversion.Scope) error {
        out.Count = in.Count
        out.LastObservedTime = in.LastObservedTime
        return nil
}

// Convert_core_EventSeries_To_v1beta1_EventSeries is an autogenerated conversion function.
func Convert_core_EventSeries_To_v1beta1_EventSeries(in *core.EventSeries, out *eventsv1beta1.EventSeries, s conversion.Scope) error {
        return autoConvert_core_EventSeries_To_v1beta1_EventSeries(in, out, s)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        runtime "k8s.io/apimachinery/pkg/runtime"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        return nil
}

/*
Copyright 2017 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
)

// Funcs returns the fuzzer functions for the extensions api group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{}
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

// Package install installs the experimental API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/extensions"
        "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(extensions.AddToScheme(scheme))
        utilruntime.Must(v1beta1.AddToScheme(scheme))
        utilruntime.Must(scheme.SetVersionPriority(v1beta1.SchemeGroupVersion))
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package extensions

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
        "k8s.io/kubernetes/pkg/apis/apps"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/kubernetes/pkg/apis/networking"
)

// GroupName is the group name use in this package
const GroupName = "extensions"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

// Builds new Scheme of known types
var (
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        AddToScheme   = SchemeBuilder.AddToScheme
)

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        // TODO this gets cleaned up when the types are fixed
        scheme.AddKnownTypes(SchemeGroupVersion,
                &apps.Deployment{},
                &apps.DeploymentList{},
                &apps.DeploymentRollback{},
                &apps.DaemonSetList{},
                &apps.DaemonSet{},
                &networking.Ingress{},
                &networking.IngressList{},
                &apps.ReplicaSet{},
                &apps.ReplicaSetList{},
                &autoscaling.Scale{},
                &networking.NetworkPolicy{},
                &networking.NetworkPolicyList{},
        )
        return nil
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "fmt"

        extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/conversion"
        "k8s.io/apimachinery/pkg/labels"
        "k8s.io/apimachinery/pkg/util/intstr"
        "k8s.io/kubernetes/pkg/apis/autoscaling"
        "k8s.io/kubernetes/pkg/apis/networking"
)

func Convert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(in *autoscaling.ScaleStatus, out *extensionsv1beta1.ScaleStatus, s conversion.Scope) error {
        out.Replicas = int32(in.Replicas)
        out.TargetSelector = in.Selector

        out.Selector = nil
        selector, err := metav1.ParseToLabelSelector(in.Selector)
        if err != nil {
                return fmt.Errorf("failed to parse selector: %v", err)
        }
        if len(selector.MatchExpressions) == 0 {
                out.Selector = selector.MatchLabels
        }

        return nil
}

func Convert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(in *extensionsv1beta1.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas

        if in.TargetSelector != "" {
                out.Selector = in.TargetSelector
        } else if in.Selector != nil {
                set := labels.Set{}
                for key, val := range in.Selector {
                        set[key] = val
                }
                out.Selector = labels.SelectorFromSet(set).String()
        } else {
                out.Selector = ""
        }
        return nil
}

func Convert_v1beta1_NetworkPolicySpec_To_networking_NetworkPolicySpec(in *extensionsv1beta1.NetworkPolicySpec, out *networking.NetworkPolicySpec, s conversion.Scope) error {
        if err := autoConvert_v1beta1_NetworkPolicySpec_To_networking_NetworkPolicySpec(in, out, s); err != nil {
                return err
        }
        if out.Ingress == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.Ingress = make([]networking.NetworkPolicyIngressRule, 0)
        }
        if out.Egress == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.Egress = make([]networking.NetworkPolicyEgressRule, 0)
        }
        return nil
}

func Convert_networking_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(in *networking.NetworkPolicySpec, out *extensionsv1beta1.NetworkPolicySpec, s conversion.Scope) error {
        if err := autoConvert_networking_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(in, out, s); err != nil {
                return err
        }
        if out.Ingress == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.Ingress = make([]extensionsv1beta1.NetworkPolicyIngressRule, 0)
        }
        if out.Egress == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.Egress = make([]extensionsv1beta1.NetworkPolicyEgressRule, 0)
        }
        return nil
}

func Convert_v1beta1_NetworkPolicyIngressRule_To_networking_NetworkPolicyIngressRule(in *extensionsv1beta1.NetworkPolicyIngressRule, out *networking.NetworkPolicyIngressRule, s conversion.Scope) error {
        if err := autoConvert_v1beta1_NetworkPolicyIngressRule_To_networking_NetworkPolicyIngressRule(in, out, s); err != nil {
                return err
        }
        if out.Ports == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.Ports = make([]networking.NetworkPolicyPort, 0)
        }
        return nil
}

func Convert_networking_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(in *networking.NetworkPolicyIngressRule, out *extensionsv1beta1.NetworkPolicyIngressRule, s conversion.Scope) error {
        if err := autoConvert_networking_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(in, out, s); err != nil {
                return err
        }
        if out.Ports == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.Ports = make([]extensionsv1beta1.NetworkPolicyPort, 0)
        }
        return nil
}

func Convert_v1beta1_NetworkPolicyEgressRule_To_networking_NetworkPolicyEgressRule(in *extensionsv1beta1.NetworkPolicyEgressRule, out *networking.NetworkPolicyEgressRule, s conversion.Scope) error {
        if err := autoConvert_v1beta1_NetworkPolicyEgressRule_To_networking_NetworkPolicyEgressRule(in, out, s); err != nil {
                return err
        }
        if out.Ports == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.Ports = make([]networking.NetworkPolicyPort, 0)
        }
        if out.To == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.To = make([]networking.NetworkPolicyPeer, 0)
        }
        return nil
}

func Convert_networking_NetworkPolicyEgressRule_To_v1beta1_NetworkPolicyEgressRule(in *networking.NetworkPolicyEgressRule, out *extensionsv1beta1.NetworkPolicyEgressRule, s conversion.Scope) error {
        if err := autoConvert_networking_NetworkPolicyEgressRule_To_v1beta1_NetworkPolicyEgressRule(in, out, s); err != nil {
                return err
        }
        if out.Ports == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.Ports = make([]extensionsv1beta1.NetworkPolicyPort, 0)
        }
        if out.To == nil {
                // Produce a zero-length non-nil slice for compatibility with previous manual conversion.
                out.To = make([]extensionsv1beta1.NetworkPolicyPeer, 0)
        }
        return nil
}

func Convert_v1beta1_IPBlock_To_networking_IPBlock(in *extensionsv1beta1.IPBlock, out *networking.IPBlock, s conversion.Scope) error {
        out.CIDR = in.CIDR

        out.Except = make([]string, len(in.Except))
        copy(out.Except, in.Except)
        return nil
}

func Convert_networking_IPBlock_To_v1beta1_IPBlock(in *networking.IPBlock, out *extensionsv1beta1.IPBlock, s conversion.Scope) error {
        out.CIDR = in.CIDR

        out.Except = make([]string, len(in.Except))
        copy(out.Except, in.Except)
        return nil
}

func Convert_v1beta1_IngressBackend_To_networking_IngressBackend(in *extensionsv1beta1.IngressBackend, out *networking.IngressBackend, s conversion.Scope) error {
        if err := autoConvert_v1beta1_IngressBackend_To_networking_IngressBackend(in, out, s); err != nil {
                return err
        }
        if len(in.ServiceName) > 0 || in.ServicePort.IntVal != 0 || in.ServicePort.StrVal != "" || in.ServicePort.Type == intstr.String {
                out.Service = &networking.IngressServiceBackend{}
                out.Service.Name = in.ServiceName
                out.Service.Port.Name = in.ServicePort.StrVal
                out.Service.Port.Number = in.ServicePort.IntVal
        }
        return nil
}

func Convert_networking_IngressBackend_To_v1beta1_IngressBackend(in *networking.IngressBackend, out *extensionsv1beta1.IngressBackend, s conversion.Scope) error {
        if err := autoConvert_networking_IngressBackend_To_v1beta1_IngressBackend(in, out, s); err != nil {
                return err
        }
        if in.Service != nil {
                out.ServiceName = in.Service.Name
                if len(in.Service.Port.Name) > 0 {
                        out.ServicePort = intstr.FromString(in.Service.Port.Name)
                } else {
                        out.ServicePort = intstr.FromInt32(in.Service.Port.Number)
                }
        }
        return nil
}

func Convert_v1beta1_IngressSpec_To_networking_IngressSpec(in *extensionsv1beta1.IngressSpec, out *networking.IngressSpec, s conversion.Scope) error {
        if err := autoConvert_v1beta1_IngressSpec_To_networking_IngressSpec(in, out, s); err != nil {
                return err
        }
        if in.Backend != nil {
                out.DefaultBackend = &networking.IngressBackend{}
                if err := Convert_v1beta1_IngressBackend_To_networking_IngressBackend(in.Backend, out.DefaultBackend, s); err != nil {
                        return err
                }
        }
        return nil
}

func Convert_networking_IngressSpec_To_v1beta1_IngressSpec(in *networking.IngressSpec, out *extensionsv1beta1.IngressSpec, s conversion.Scope) error {
        if err := autoConvert_networking_IngressSpec_To_v1beta1_IngressSpec(in, out, s); err != nil {
                return err
        }
        if in.DefaultBackend != nil {
                out.Backend = &extensionsv1beta1.IngressBackend{}
                if err := Convert_networking_IngressBackend_To_v1beta1_IngressBackend(in.DefaultBackend, out.Backend, s); err != nil {
                        return err
                }
        }
        return nil
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        "math"

        v1 "k8s.io/api/core/v1"
        extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/util/intstr"
)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
        return RegisterDefaults(scheme)
}

func SetDefaults_DaemonSet(obj *extensionsv1beta1.DaemonSet) {
        labels := obj.Spec.Template.Labels

        // TODO: support templates defined elsewhere when we support them in the API
        if labels != nil {
                if obj.Spec.Selector == nil {
                        obj.Spec.Selector = &metav1.LabelSelector{
                                MatchLabels: labels,
                        }
                }
                if len(obj.Labels) == 0 {
                        obj.Labels = labels
                }
        }
        updateStrategy := &obj.Spec.UpdateStrategy
        if updateStrategy.Type == "" {
                updateStrategy.Type = extensionsv1beta1.OnDeleteDaemonSetStrategyType
        }
        if updateStrategy.Type == extensionsv1beta1.RollingUpdateDaemonSetStrategyType {
                if updateStrategy.RollingUpdate == nil {
                        rollingUpdate := extensionsv1beta1.RollingUpdateDaemonSet{}
                        updateStrategy.RollingUpdate = &rollingUpdate
                }
                if updateStrategy.RollingUpdate.MaxUnavailable == nil {
                        // Set default MaxUnavailable as 1 by default.
                        maxUnavailable := intstr.FromInt32(1)
                        updateStrategy.RollingUpdate.MaxUnavailable = &maxUnavailable
                }
                if updateStrategy.RollingUpdate.MaxSurge == nil {
                        // Set default MaxSurge as 0 by default.
                        maxSurge := intstr.FromInt32(0)
                        updateStrategy.RollingUpdate.MaxSurge = &maxSurge
                }
        }
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = 10
        }
}

func SetDefaults_Deployment(obj *extensionsv1beta1.Deployment) {
        // Default labels and selector to labels from pod template spec.
        labels := obj.Spec.Template.Labels

        if labels != nil {
                if obj.Spec.Selector == nil {
                        obj.Spec.Selector = &metav1.LabelSelector{MatchLabels: labels}
                }
                if len(obj.Labels) == 0 {
                        obj.Labels = labels
                }
        }
        // Set extensionsv1beta1.DeploymentSpec.Replicas to 1 if it is not set.
        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
        strategy := &obj.Spec.Strategy
        // Set default extensionsv1beta1.DeploymentStrategyType as RollingUpdate.
        if strategy.Type == "" {
                strategy.Type = extensionsv1beta1.RollingUpdateDeploymentStrategyType
        }
        if strategy.Type == extensionsv1beta1.RollingUpdateDeploymentStrategyType || strategy.RollingUpdate != nil {
                if strategy.RollingUpdate == nil {
                        rollingUpdate := extensionsv1beta1.RollingUpdateDeployment{}
                        strategy.RollingUpdate = &rollingUpdate
                }
                if strategy.RollingUpdate.MaxUnavailable == nil {
                        // Set default MaxUnavailable as 1 by default.
                        maxUnavailable := intstr.FromInt32(1)
                        strategy.RollingUpdate.MaxUnavailable = &maxUnavailable
                }
                if strategy.RollingUpdate.MaxSurge == nil {
                        // Set default MaxSurge as 1 by default.
                        maxSurge := intstr.FromInt32(1)
                        strategy.RollingUpdate.MaxSurge = &maxSurge
                }
        }
        // Set extensionsv1beta1.DeploymentSpec.ProgressDeadlineSeconds to MaxInt,
        // which has the same meaning as unset.
        if obj.Spec.ProgressDeadlineSeconds == nil {
                obj.Spec.ProgressDeadlineSeconds = new(int32)
                *obj.Spec.ProgressDeadlineSeconds = math.MaxInt32
        }
        // Set extensionsv1beta1.DeploymentSpec.RevisionHistoryLimit to MaxInt32,
        // which has the same meaning as unset.
        if obj.Spec.RevisionHistoryLimit == nil {
                obj.Spec.RevisionHistoryLimit = new(int32)
                *obj.Spec.RevisionHistoryLimit = math.MaxInt32
        }
}

func SetDefaults_ReplicaSet(obj *extensionsv1beta1.ReplicaSet) {
        labels := obj.Spec.Template.Labels

        // TODO: support templates defined elsewhere when we support them in the API
        if labels != nil {
                if obj.Spec.Selector == nil {
                        obj.Spec.Selector = &metav1.LabelSelector{
                                MatchLabels: labels,
                        }
                }
                if len(obj.Labels) == 0 {
                        obj.Labels = labels
                }
        }
        if obj.Spec.Replicas == nil {
                obj.Spec.Replicas = new(int32)
                *obj.Spec.Replicas = 1
        }
}

func SetDefaults_NetworkPolicy(obj *extensionsv1beta1.NetworkPolicy) {
        // Default any undefined Protocol fields to TCP.
        for _, i := range obj.Spec.Ingress {
                for _, p := range i.Ports {
                        if p.Protocol == nil {
                                proto := v1.ProtocolTCP
                                p.Protocol = &proto
                        }
                }
        }

        if len(obj.Spec.PolicyTypes) == 0 {
                // Any policy that does not specify policyTypes implies at least "Ingress".
                obj.Spec.PolicyTypes = []extensionsv1beta1.PolicyType{extensionsv1beta1.PolicyTypeIngress}
                if len(obj.Spec.Egress) != 0 {
                        obj.Spec.PolicyTypes = append(obj.Spec.PolicyTypes, extensionsv1beta1.PolicyTypeEgress)
                }
        }
}

func SetDefaults_HTTPIngressPath(obj *extensionsv1beta1.HTTPIngressPath) {
        var defaultPathType = extensionsv1beta1.PathTypeImplementationSpecific
        if obj.PathType == nil {
                obj.PathType = &defaultPathType
        }
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

package v1beta1

import (
        extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "extensions"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &extensionsv1beta1.SchemeBuilder
        AddToScheme        = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(addDefaultingFuncs)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1beta1

import (
        unsafe "unsafe"

        v1 "k8s.io/api/core/v1"
        extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        intstr "k8s.io/apimachinery/pkg/util/intstr"
        apps "k8s.io/kubernetes/pkg/apis/apps"
        autoscaling "k8s.io/kubernetes/pkg/apis/autoscaling"
        core "k8s.io/kubernetes/pkg/apis/core"
        corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
        networking "k8s.io/kubernetes/pkg/apis/networking"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DaemonSet)(nil), (*apps.DaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DaemonSet_To_apps_DaemonSet(a.(*extensionsv1beta1.DaemonSet), b.(*apps.DaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSet)(nil), (*extensionsv1beta1.DaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSet_To_v1beta1_DaemonSet(a.(*apps.DaemonSet), b.(*extensionsv1beta1.DaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DaemonSetCondition)(nil), (*apps.DaemonSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DaemonSetCondition_To_apps_DaemonSetCondition(a.(*extensionsv1beta1.DaemonSetCondition), b.(*apps.DaemonSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetCondition)(nil), (*extensionsv1beta1.DaemonSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetCondition_To_v1beta1_DaemonSetCondition(a.(*apps.DaemonSetCondition), b.(*extensionsv1beta1.DaemonSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DaemonSetList)(nil), (*apps.DaemonSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DaemonSetList_To_apps_DaemonSetList(a.(*extensionsv1beta1.DaemonSetList), b.(*apps.DaemonSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetList)(nil), (*extensionsv1beta1.DaemonSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetList_To_v1beta1_DaemonSetList(a.(*apps.DaemonSetList), b.(*extensionsv1beta1.DaemonSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DaemonSetSpec)(nil), (*apps.DaemonSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DaemonSetSpec_To_apps_DaemonSetSpec(a.(*extensionsv1beta1.DaemonSetSpec), b.(*apps.DaemonSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetSpec)(nil), (*extensionsv1beta1.DaemonSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetSpec_To_v1beta1_DaemonSetSpec(a.(*apps.DaemonSetSpec), b.(*extensionsv1beta1.DaemonSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DaemonSetStatus)(nil), (*apps.DaemonSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DaemonSetStatus_To_apps_DaemonSetStatus(a.(*extensionsv1beta1.DaemonSetStatus), b.(*apps.DaemonSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetStatus)(nil), (*extensionsv1beta1.DaemonSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetStatus_To_v1beta1_DaemonSetStatus(a.(*apps.DaemonSetStatus), b.(*extensionsv1beta1.DaemonSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DaemonSetUpdateStrategy)(nil), (*apps.DaemonSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(a.(*extensionsv1beta1.DaemonSetUpdateStrategy), b.(*apps.DaemonSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DaemonSetUpdateStrategy)(nil), (*extensionsv1beta1.DaemonSetUpdateStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DaemonSetUpdateStrategy_To_v1beta1_DaemonSetUpdateStrategy(a.(*apps.DaemonSetUpdateStrategy), b.(*extensionsv1beta1.DaemonSetUpdateStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.Deployment)(nil), (*apps.Deployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Deployment_To_apps_Deployment(a.(*extensionsv1beta1.Deployment), b.(*apps.Deployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.Deployment)(nil), (*extensionsv1beta1.Deployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_Deployment_To_v1beta1_Deployment(a.(*apps.Deployment), b.(*extensionsv1beta1.Deployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DeploymentCondition)(nil), (*apps.DeploymentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition(a.(*extensionsv1beta1.DeploymentCondition), b.(*apps.DeploymentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentCondition)(nil), (*extensionsv1beta1.DeploymentCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition(a.(*apps.DeploymentCondition), b.(*extensionsv1beta1.DeploymentCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DeploymentList)(nil), (*apps.DeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentList_To_apps_DeploymentList(a.(*extensionsv1beta1.DeploymentList), b.(*apps.DeploymentList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentList)(nil), (*extensionsv1beta1.DeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentList_To_v1beta1_DeploymentList(a.(*apps.DeploymentList), b.(*extensionsv1beta1.DeploymentList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DeploymentRollback)(nil), (*apps.DeploymentRollback)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback(a.(*extensionsv1beta1.DeploymentRollback), b.(*apps.DeploymentRollback), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentRollback)(nil), (*extensionsv1beta1.DeploymentRollback)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback(a.(*apps.DeploymentRollback), b.(*extensionsv1beta1.DeploymentRollback), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DeploymentSpec)(nil), (*apps.DeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(a.(*extensionsv1beta1.DeploymentSpec), b.(*apps.DeploymentSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentSpec)(nil), (*extensionsv1beta1.DeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(a.(*apps.DeploymentSpec), b.(*extensionsv1beta1.DeploymentSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DeploymentStatus)(nil), (*apps.DeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(a.(*extensionsv1beta1.DeploymentStatus), b.(*apps.DeploymentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentStatus)(nil), (*extensionsv1beta1.DeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(a.(*apps.DeploymentStatus), b.(*extensionsv1beta1.DeploymentStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.DeploymentStrategy)(nil), (*apps.DeploymentStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(a.(*extensionsv1beta1.DeploymentStrategy), b.(*apps.DeploymentStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.DeploymentStrategy)(nil), (*extensionsv1beta1.DeploymentStrategy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(a.(*apps.DeploymentStrategy), b.(*extensionsv1beta1.DeploymentStrategy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.HTTPIngressPath)(nil), (*networking.HTTPIngressPath)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(a.(*extensionsv1beta1.HTTPIngressPath), b.(*networking.HTTPIngressPath), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.HTTPIngressPath)(nil), (*extensionsv1beta1.HTTPIngressPath)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(a.(*networking.HTTPIngressPath), b.(*extensionsv1beta1.HTTPIngressPath), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.HTTPIngressRuleValue)(nil), (*networking.HTTPIngressRuleValue)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(a.(*extensionsv1beta1.HTTPIngressRuleValue), b.(*networking.HTTPIngressRuleValue), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.HTTPIngressRuleValue)(nil), (*extensionsv1beta1.HTTPIngressRuleValue)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(a.(*networking.HTTPIngressRuleValue), b.(*extensionsv1beta1.HTTPIngressRuleValue), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.Ingress)(nil), (*networking.Ingress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Ingress_To_networking_Ingress(a.(*extensionsv1beta1.Ingress), b.(*networking.Ingress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.Ingress)(nil), (*extensionsv1beta1.Ingress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_Ingress_To_v1beta1_Ingress(a.(*networking.Ingress), b.(*extensionsv1beta1.Ingress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.IngressList)(nil), (*networking.IngressList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressList_To_networking_IngressList(a.(*extensionsv1beta1.IngressList), b.(*networking.IngressList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.IngressList)(nil), (*extensionsv1beta1.IngressList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressList_To_v1beta1_IngressList(a.(*networking.IngressList), b.(*extensionsv1beta1.IngressList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.IngressLoadBalancerIngress)(nil), (*networking.IngressLoadBalancerIngress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressLoadBalancerIngress_To_networking_IngressLoadBalancerIngress(a.(*extensionsv1beta1.IngressLoadBalancerIngress), b.(*networking.IngressLoadBalancerIngress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.IngressLoadBalancerIngress)(nil), (*extensionsv1beta1.IngressLoadBalancerIngress)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressLoadBalancerIngress_To_v1beta1_IngressLoadBalancerIngress(a.(*networking.IngressLoadBalancerIngress), b.(*extensionsv1beta1.IngressLoadBalancerIngress), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.IngressLoadBalancerStatus)(nil), (*networking.IngressLoadBalancerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressLoadBalancerStatus_To_networking_IngressLoadBalancerStatus(a.(*extensionsv1beta1.IngressLoadBalancerStatus), b.(*networking.IngressLoadBalancerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.IngressLoadBalancerStatus)(nil), (*extensionsv1beta1.IngressLoadBalancerStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressLoadBalancerStatus_To_v1beta1_IngressLoadBalancerStatus(a.(*networking.IngressLoadBalancerStatus), b.(*extensionsv1beta1.IngressLoadBalancerStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.IngressPortStatus)(nil), (*networking.IngressPortStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressPortStatus_To_networking_IngressPortStatus(a.(*extensionsv1beta1.IngressPortStatus), b.(*networking.IngressPortStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.IngressPortStatus)(nil), (*extensionsv1beta1.IngressPortStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressPortStatus_To_v1beta1_IngressPortStatus(a.(*networking.IngressPortStatus), b.(*extensionsv1beta1.IngressPortStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.IngressRule)(nil), (*networking.IngressRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressRule_To_networking_IngressRule(a.(*extensionsv1beta1.IngressRule), b.(*networking.IngressRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.IngressRule)(nil), (*extensionsv1beta1.IngressRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressRule_To_v1beta1_IngressRule(a.(*networking.IngressRule), b.(*extensionsv1beta1.IngressRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.IngressRuleValue)(nil), (*networking.IngressRuleValue)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(a.(*extensionsv1beta1.IngressRuleValue), b.(*networking.IngressRuleValue), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.IngressRuleValue)(nil), (*extensionsv1beta1.IngressRuleValue)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(a.(*networking.IngressRuleValue), b.(*extensionsv1beta1.IngressRuleValue), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.IngressStatus)(nil), (*networking.IngressStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressStatus_To_networking_IngressStatus(a.(*extensionsv1beta1.IngressStatus), b.(*networking.IngressStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.IngressStatus)(nil), (*extensionsv1beta1.IngressStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressStatus_To_v1beta1_IngressStatus(a.(*networking.IngressStatus), b.(*extensionsv1beta1.IngressStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.IngressTLS)(nil), (*networking.IngressTLS)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressTLS_To_networking_IngressTLS(a.(*extensionsv1beta1.IngressTLS), b.(*networking.IngressTLS), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.IngressTLS)(nil), (*extensionsv1beta1.IngressTLS)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressTLS_To_v1beta1_IngressTLS(a.(*networking.IngressTLS), b.(*extensionsv1beta1.IngressTLS), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.NetworkPolicy)(nil), (*networking.NetworkPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NetworkPolicy_To_networking_NetworkPolicy(a.(*extensionsv1beta1.NetworkPolicy), b.(*networking.NetworkPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.NetworkPolicy)(nil), (*extensionsv1beta1.NetworkPolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_NetworkPolicy_To_v1beta1_NetworkPolicy(a.(*networking.NetworkPolicy), b.(*extensionsv1beta1.NetworkPolicy), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.NetworkPolicyList)(nil), (*networking.NetworkPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NetworkPolicyList_To_networking_NetworkPolicyList(a.(*extensionsv1beta1.NetworkPolicyList), b.(*networking.NetworkPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.NetworkPolicyList)(nil), (*extensionsv1beta1.NetworkPolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_NetworkPolicyList_To_v1beta1_NetworkPolicyList(a.(*networking.NetworkPolicyList), b.(*extensionsv1beta1.NetworkPolicyList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.NetworkPolicyPeer)(nil), (*networking.NetworkPolicyPeer)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NetworkPolicyPeer_To_networking_NetworkPolicyPeer(a.(*extensionsv1beta1.NetworkPolicyPeer), b.(*networking.NetworkPolicyPeer), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.NetworkPolicyPeer)(nil), (*extensionsv1beta1.NetworkPolicyPeer)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(a.(*networking.NetworkPolicyPeer), b.(*extensionsv1beta1.NetworkPolicyPeer), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.NetworkPolicyPort)(nil), (*networking.NetworkPolicyPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NetworkPolicyPort_To_networking_NetworkPolicyPort(a.(*extensionsv1beta1.NetworkPolicyPort), b.(*networking.NetworkPolicyPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*networking.NetworkPolicyPort)(nil), (*extensionsv1beta1.NetworkPolicyPort)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort(a.(*networking.NetworkPolicyPort), b.(*extensionsv1beta1.NetworkPolicyPort), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.ReplicaSet)(nil), (*apps.ReplicaSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ReplicaSet_To_apps_ReplicaSet(a.(*extensionsv1beta1.ReplicaSet), b.(*apps.ReplicaSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSet)(nil), (*extensionsv1beta1.ReplicaSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSet_To_v1beta1_ReplicaSet(a.(*apps.ReplicaSet), b.(*extensionsv1beta1.ReplicaSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.ReplicaSetCondition)(nil), (*apps.ReplicaSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ReplicaSetCondition_To_apps_ReplicaSetCondition(a.(*extensionsv1beta1.ReplicaSetCondition), b.(*apps.ReplicaSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetCondition)(nil), (*extensionsv1beta1.ReplicaSetCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetCondition_To_v1beta1_ReplicaSetCondition(a.(*apps.ReplicaSetCondition), b.(*extensionsv1beta1.ReplicaSetCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.ReplicaSetList)(nil), (*apps.ReplicaSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ReplicaSetList_To_apps_ReplicaSetList(a.(*extensionsv1beta1.ReplicaSetList), b.(*apps.ReplicaSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetList)(nil), (*extensionsv1beta1.ReplicaSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetList_To_v1beta1_ReplicaSetList(a.(*apps.ReplicaSetList), b.(*extensionsv1beta1.ReplicaSetList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.ReplicaSetSpec)(nil), (*apps.ReplicaSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ReplicaSetSpec_To_apps_ReplicaSetSpec(a.(*extensionsv1beta1.ReplicaSetSpec), b.(*apps.ReplicaSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetSpec)(nil), (*extensionsv1beta1.ReplicaSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(a.(*apps.ReplicaSetSpec), b.(*extensionsv1beta1.ReplicaSetSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.ReplicaSetStatus)(nil), (*apps.ReplicaSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ReplicaSetStatus_To_apps_ReplicaSetStatus(a.(*extensionsv1beta1.ReplicaSetStatus), b.(*apps.ReplicaSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.ReplicaSetStatus)(nil), (*extensionsv1beta1.ReplicaSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(a.(*apps.ReplicaSetStatus), b.(*extensionsv1beta1.ReplicaSetStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.RollbackConfig)(nil), (*apps.RollbackConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_RollbackConfig_To_apps_RollbackConfig(a.(*extensionsv1beta1.RollbackConfig), b.(*apps.RollbackConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollbackConfig)(nil), (*extensionsv1beta1.RollbackConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollbackConfig_To_v1beta1_RollbackConfig(a.(*apps.RollbackConfig), b.(*extensionsv1beta1.RollbackConfig), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.RollingUpdateDaemonSet)(nil), (*apps.RollingUpdateDaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(a.(*extensionsv1beta1.RollingUpdateDaemonSet), b.(*apps.RollingUpdateDaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateDaemonSet)(nil), (*extensionsv1beta1.RollingUpdateDaemonSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateDaemonSet_To_v1beta1_RollingUpdateDaemonSet(a.(*apps.RollingUpdateDaemonSet), b.(*extensionsv1beta1.RollingUpdateDaemonSet), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.RollingUpdateDeployment)(nil), (*apps.RollingUpdateDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(a.(*extensionsv1beta1.RollingUpdateDeployment), b.(*apps.RollingUpdateDeployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*apps.RollingUpdateDeployment)(nil), (*extensionsv1beta1.RollingUpdateDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(a.(*apps.RollingUpdateDeployment), b.(*extensionsv1beta1.RollingUpdateDeployment), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.Scale)(nil), (*autoscaling.Scale)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_Scale_To_autoscaling_Scale(a.(*extensionsv1beta1.Scale), b.(*autoscaling.Scale), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.Scale)(nil), (*extensionsv1beta1.Scale)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_Scale_To_v1beta1_Scale(a.(*autoscaling.Scale), b.(*extensionsv1beta1.Scale), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*extensionsv1beta1.ScaleSpec)(nil), (*autoscaling.ScaleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(a.(*extensionsv1beta1.ScaleSpec), b.(*autoscaling.ScaleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*autoscaling.ScaleSpec)(nil), (*extensionsv1beta1.ScaleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(a.(*autoscaling.ScaleSpec), b.(*extensionsv1beta1.ScaleSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*autoscaling.ScaleStatus)(nil), (*extensionsv1beta1.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(a.(*autoscaling.ScaleStatus), b.(*extensionsv1beta1.ScaleStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*networking.IPBlock)(nil), (*extensionsv1beta1.IPBlock)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IPBlock_To_v1beta1_IPBlock(a.(*networking.IPBlock), b.(*extensionsv1beta1.IPBlock), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*networking.IngressBackend)(nil), (*extensionsv1beta1.IngressBackend)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressBackend_To_v1beta1_IngressBackend(a.(*networking.IngressBackend), b.(*extensionsv1beta1.IngressBackend), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*networking.IngressSpec)(nil), (*extensionsv1beta1.IngressSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_IngressSpec_To_v1beta1_IngressSpec(a.(*networking.IngressSpec), b.(*extensionsv1beta1.IngressSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*networking.NetworkPolicyEgressRule)(nil), (*extensionsv1beta1.NetworkPolicyEgressRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_NetworkPolicyEgressRule_To_v1beta1_NetworkPolicyEgressRule(a.(*networking.NetworkPolicyEgressRule), b.(*extensionsv1beta1.NetworkPolicyEgressRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*networking.NetworkPolicyIngressRule)(nil), (*extensionsv1beta1.NetworkPolicyIngressRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(a.(*networking.NetworkPolicyIngressRule), b.(*extensionsv1beta1.NetworkPolicyIngressRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*networking.NetworkPolicySpec)(nil), (*extensionsv1beta1.NetworkPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_networking_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(a.(*networking.NetworkPolicySpec), b.(*extensionsv1beta1.NetworkPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*extensionsv1beta1.IPBlock)(nil), (*networking.IPBlock)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IPBlock_To_networking_IPBlock(a.(*extensionsv1beta1.IPBlock), b.(*networking.IPBlock), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*extensionsv1beta1.IngressBackend)(nil), (*networking.IngressBackend)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressBackend_To_networking_IngressBackend(a.(*extensionsv1beta1.IngressBackend), b.(*networking.IngressBackend), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*extensionsv1beta1.IngressSpec)(nil), (*networking.IngressSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_IngressSpec_To_networking_IngressSpec(a.(*extensionsv1beta1.IngressSpec), b.(*networking.IngressSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*extensionsv1beta1.NetworkPolicyEgressRule)(nil), (*networking.NetworkPolicyEgressRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NetworkPolicyEgressRule_To_networking_NetworkPolicyEgressRule(a.(*extensionsv1beta1.NetworkPolicyEgressRule), b.(*networking.NetworkPolicyEgressRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*extensionsv1beta1.NetworkPolicyIngressRule)(nil), (*networking.NetworkPolicyIngressRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NetworkPolicyIngressRule_To_networking_NetworkPolicyIngressRule(a.(*extensionsv1beta1.NetworkPolicyIngressRule), b.(*networking.NetworkPolicyIngressRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*extensionsv1beta1.NetworkPolicySpec)(nil), (*networking.NetworkPolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_NetworkPolicySpec_To_networking_NetworkPolicySpec(a.(*extensionsv1beta1.NetworkPolicySpec), b.(*networking.NetworkPolicySpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddConversionFunc((*extensionsv1beta1.ScaleStatus)(nil), (*autoscaling.ScaleStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(a.(*extensionsv1beta1.ScaleStatus), b.(*autoscaling.ScaleStatus), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1beta1_DaemonSet_To_apps_DaemonSet(in *extensionsv1beta1.DaemonSet, out *apps.DaemonSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_DaemonSetSpec_To_apps_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_DaemonSetStatus_To_apps_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_DaemonSet_To_apps_DaemonSet is an autogenerated conversion function.
func Convert_v1beta1_DaemonSet_To_apps_DaemonSet(in *extensionsv1beta1.DaemonSet, out *apps.DaemonSet, s conversion.Scope) error {
        return autoConvert_v1beta1_DaemonSet_To_apps_DaemonSet(in, out, s)
}

func autoConvert_apps_DaemonSet_To_v1beta1_DaemonSet(in *apps.DaemonSet, out *extensionsv1beta1.DaemonSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_DaemonSetSpec_To_v1beta1_DaemonSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_DaemonSetStatus_To_v1beta1_DaemonSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_DaemonSet_To_v1beta1_DaemonSet is an autogenerated conversion function.
func Convert_apps_DaemonSet_To_v1beta1_DaemonSet(in *apps.DaemonSet, out *extensionsv1beta1.DaemonSet, s conversion.Scope) error {
        return autoConvert_apps_DaemonSet_To_v1beta1_DaemonSet(in, out, s)
}

func autoConvert_v1beta1_DaemonSetCondition_To_apps_DaemonSetCondition(in *extensionsv1beta1.DaemonSetCondition, out *apps.DaemonSetCondition, s conversion.Scope) error {
        out.Type = apps.DaemonSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta1_DaemonSetCondition_To_apps_DaemonSetCondition is an autogenerated conversion function.
func Convert_v1beta1_DaemonSetCondition_To_apps_DaemonSetCondition(in *extensionsv1beta1.DaemonSetCondition, out *apps.DaemonSetCondition, s conversion.Scope) error {
        return autoConvert_v1beta1_DaemonSetCondition_To_apps_DaemonSetCondition(in, out, s)
}

func autoConvert_apps_DaemonSetCondition_To_v1beta1_DaemonSetCondition(in *apps.DaemonSetCondition, out *extensionsv1beta1.DaemonSetCondition, s conversion.Scope) error {
        out.Type = extensionsv1beta1.DaemonSetConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_DaemonSetCondition_To_v1beta1_DaemonSetCondition is an autogenerated conversion function.
func Convert_apps_DaemonSetCondition_To_v1beta1_DaemonSetCondition(in *apps.DaemonSetCondition, out *extensionsv1beta1.DaemonSetCondition, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetCondition_To_v1beta1_DaemonSetCondition(in, out, s)
}

func autoConvert_v1beta1_DaemonSetList_To_apps_DaemonSetList(in *extensionsv1beta1.DaemonSetList, out *apps.DaemonSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.DaemonSet, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_DaemonSet_To_apps_DaemonSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_DaemonSetList_To_apps_DaemonSetList is an autogenerated conversion function.
func Convert_v1beta1_DaemonSetList_To_apps_DaemonSetList(in *extensionsv1beta1.DaemonSetList, out *apps.DaemonSetList, s conversion.Scope) error {
        return autoConvert_v1beta1_DaemonSetList_To_apps_DaemonSetList(in, out, s)
}

func autoConvert_apps_DaemonSetList_To_v1beta1_DaemonSetList(in *apps.DaemonSetList, out *extensionsv1beta1.DaemonSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]extensionsv1beta1.DaemonSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_DaemonSet_To_v1beta1_DaemonSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_DaemonSetList_To_v1beta1_DaemonSetList is an autogenerated conversion function.
func Convert_apps_DaemonSetList_To_v1beta1_DaemonSetList(in *apps.DaemonSetList, out *extensionsv1beta1.DaemonSetList, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetList_To_v1beta1_DaemonSetList(in, out, s)
}

func autoConvert_v1beta1_DaemonSetSpec_To_apps_DaemonSetSpec(in *extensionsv1beta1.DaemonSetSpec, out *apps.DaemonSetSpec, s conversion.Scope) error {
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.TemplateGeneration = in.TemplateGeneration
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        return nil
}

// Convert_v1beta1_DaemonSetSpec_To_apps_DaemonSetSpec is an autogenerated conversion function.
func Convert_v1beta1_DaemonSetSpec_To_apps_DaemonSetSpec(in *extensionsv1beta1.DaemonSetSpec, out *apps.DaemonSetSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_DaemonSetSpec_To_apps_DaemonSetSpec(in, out, s)
}

func autoConvert_apps_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in *apps.DaemonSetSpec, out *extensionsv1beta1.DaemonSetSpec, s conversion.Scope) error {
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_apps_DaemonSetUpdateStrategy_To_v1beta1_DaemonSetUpdateStrategy(&in.UpdateStrategy, &out.UpdateStrategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.TemplateGeneration = in.TemplateGeneration
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        return nil
}

// Convert_apps_DaemonSetSpec_To_v1beta1_DaemonSetSpec is an autogenerated conversion function.
func Convert_apps_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in *apps.DaemonSetSpec, out *extensionsv1beta1.DaemonSetSpec, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetSpec_To_v1beta1_DaemonSetSpec(in, out, s)
}

func autoConvert_v1beta1_DaemonSetStatus_To_apps_DaemonSetStatus(in *extensionsv1beta1.DaemonSetStatus, out *apps.DaemonSetStatus, s conversion.Scope) error {
        out.CurrentNumberScheduled = in.CurrentNumberScheduled
        out.NumberMisscheduled = in.NumberMisscheduled
        out.DesiredNumberScheduled = in.DesiredNumberScheduled
        out.NumberReady = in.NumberReady
        out.ObservedGeneration = in.ObservedGeneration
        out.UpdatedNumberScheduled = in.UpdatedNumberScheduled
        out.NumberAvailable = in.NumberAvailable
        out.NumberUnavailable = in.NumberUnavailable
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]apps.DaemonSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1beta1_DaemonSetStatus_To_apps_DaemonSetStatus is an autogenerated conversion function.
func Convert_v1beta1_DaemonSetStatus_To_apps_DaemonSetStatus(in *extensionsv1beta1.DaemonSetStatus, out *apps.DaemonSetStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_DaemonSetStatus_To_apps_DaemonSetStatus(in, out, s)
}

func autoConvert_apps_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in *apps.DaemonSetStatus, out *extensionsv1beta1.DaemonSetStatus, s conversion.Scope) error {
        out.CurrentNumberScheduled = in.CurrentNumberScheduled
        out.NumberMisscheduled = in.NumberMisscheduled
        out.DesiredNumberScheduled = in.DesiredNumberScheduled
        out.NumberReady = in.NumberReady
        out.ObservedGeneration = in.ObservedGeneration
        out.UpdatedNumberScheduled = in.UpdatedNumberScheduled
        out.NumberAvailable = in.NumberAvailable
        out.NumberUnavailable = in.NumberUnavailable
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        out.Conditions = *(*[]extensionsv1beta1.DaemonSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_apps_DaemonSetStatus_To_v1beta1_DaemonSetStatus is an autogenerated conversion function.
func Convert_apps_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in *apps.DaemonSetStatus, out *extensionsv1beta1.DaemonSetStatus, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetStatus_To_v1beta1_DaemonSetStatus(in, out, s)
}

func autoConvert_v1beta1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in *extensionsv1beta1.DaemonSetUpdateStrategy, out *apps.DaemonSetUpdateStrategy, s conversion.Scope) error {
        out.Type = apps.DaemonSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateDaemonSet)
                if err := Convert_v1beta1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1beta1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy is an autogenerated conversion function.
func Convert_v1beta1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in *extensionsv1beta1.DaemonSetUpdateStrategy, out *apps.DaemonSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_v1beta1_DaemonSetUpdateStrategy_To_apps_DaemonSetUpdateStrategy(in, out, s)
}

func autoConvert_apps_DaemonSetUpdateStrategy_To_v1beta1_DaemonSetUpdateStrategy(in *apps.DaemonSetUpdateStrategy, out *extensionsv1beta1.DaemonSetUpdateStrategy, s conversion.Scope) error {
        out.Type = extensionsv1beta1.DaemonSetUpdateStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(extensionsv1beta1.RollingUpdateDaemonSet)
                if err := Convert_apps_RollingUpdateDaemonSet_To_v1beta1_RollingUpdateDaemonSet(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_DaemonSetUpdateStrategy_To_v1beta1_DaemonSetUpdateStrategy is an autogenerated conversion function.
func Convert_apps_DaemonSetUpdateStrategy_To_v1beta1_DaemonSetUpdateStrategy(in *apps.DaemonSetUpdateStrategy, out *extensionsv1beta1.DaemonSetUpdateStrategy, s conversion.Scope) error {
        return autoConvert_apps_DaemonSetUpdateStrategy_To_v1beta1_DaemonSetUpdateStrategy(in, out, s)
}

func autoConvert_v1beta1_Deployment_To_apps_Deployment(in *extensionsv1beta1.Deployment, out *apps.Deployment, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_Deployment_To_apps_Deployment is an autogenerated conversion function.
func Convert_v1beta1_Deployment_To_apps_Deployment(in *extensionsv1beta1.Deployment, out *apps.Deployment, s conversion.Scope) error {
        return autoConvert_v1beta1_Deployment_To_apps_Deployment(in, out, s)
}

func autoConvert_apps_Deployment_To_v1beta1_Deployment(in *apps.Deployment, out *extensionsv1beta1.Deployment, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_Deployment_To_v1beta1_Deployment is an autogenerated conversion function.
func Convert_apps_Deployment_To_v1beta1_Deployment(in *apps.Deployment, out *extensionsv1beta1.Deployment, s conversion.Scope) error {
        return autoConvert_apps_Deployment_To_v1beta1_Deployment(in, out, s)
}

func autoConvert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition(in *extensionsv1beta1.DeploymentCondition, out *apps.DeploymentCondition, s conversion.Scope) error {
        out.Type = apps.DeploymentConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition is an autogenerated conversion function.
func Convert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition(in *extensionsv1beta1.DeploymentCondition, out *apps.DeploymentCondition, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentCondition_To_apps_DeploymentCondition(in, out, s)
}

func autoConvert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition(in *apps.DeploymentCondition, out *extensionsv1beta1.DeploymentCondition, s conversion.Scope) error {
        out.Type = extensionsv1beta1.DeploymentConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastUpdateTime = in.LastUpdateTime
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition is an autogenerated conversion function.
func Convert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition(in *apps.DeploymentCondition, out *extensionsv1beta1.DeploymentCondition, s conversion.Scope) error {
        return autoConvert_apps_DeploymentCondition_To_v1beta1_DeploymentCondition(in, out, s)
}

func autoConvert_v1beta1_DeploymentList_To_apps_DeploymentList(in *extensionsv1beta1.DeploymentList, out *apps.DeploymentList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.Deployment, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_Deployment_To_apps_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_DeploymentList_To_apps_DeploymentList is an autogenerated conversion function.
func Convert_v1beta1_DeploymentList_To_apps_DeploymentList(in *extensionsv1beta1.DeploymentList, out *apps.DeploymentList, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentList_To_apps_DeploymentList(in, out, s)
}

func autoConvert_apps_DeploymentList_To_v1beta1_DeploymentList(in *apps.DeploymentList, out *extensionsv1beta1.DeploymentList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]extensionsv1beta1.Deployment, len(*in))
                for i := range *in {
                        if err := Convert_apps_Deployment_To_v1beta1_Deployment(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_DeploymentList_To_v1beta1_DeploymentList is an autogenerated conversion function.
func Convert_apps_DeploymentList_To_v1beta1_DeploymentList(in *apps.DeploymentList, out *extensionsv1beta1.DeploymentList, s conversion.Scope) error {
        return autoConvert_apps_DeploymentList_To_v1beta1_DeploymentList(in, out, s)
}

func autoConvert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback(in *extensionsv1beta1.DeploymentRollback, out *apps.DeploymentRollback, s conversion.Scope) error {
        out.Name = in.Name
        out.UpdatedAnnotations = *(*map[string]string)(unsafe.Pointer(&in.UpdatedAnnotations))
        if err := Convert_v1beta1_RollbackConfig_To_apps_RollbackConfig(&in.RollbackTo, &out.RollbackTo, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback is an autogenerated conversion function.
func Convert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback(in *extensionsv1beta1.DeploymentRollback, out *apps.DeploymentRollback, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentRollback_To_apps_DeploymentRollback(in, out, s)
}

func autoConvert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback(in *apps.DeploymentRollback, out *extensionsv1beta1.DeploymentRollback, s conversion.Scope) error {
        out.Name = in.Name
        out.UpdatedAnnotations = *(*map[string]string)(unsafe.Pointer(&in.UpdatedAnnotations))
        if err := Convert_apps_RollbackConfig_To_v1beta1_RollbackConfig(&in.RollbackTo, &out.RollbackTo, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback is an autogenerated conversion function.
func Convert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback(in *apps.DeploymentRollback, out *extensionsv1beta1.DeploymentRollback, s conversion.Scope) error {
        return autoConvert_apps_DeploymentRollback_To_v1beta1_DeploymentRollback(in, out, s)
}

func autoConvert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(in *extensionsv1beta1.DeploymentSpec, out *apps.DeploymentSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.Paused = in.Paused
        out.RollbackTo = (*apps.RollbackConfig)(unsafe.Pointer(in.RollbackTo))
        out.ProgressDeadlineSeconds = (*int32)(unsafe.Pointer(in.ProgressDeadlineSeconds))
        return nil
}

// Convert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec is an autogenerated conversion function.
func Convert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(in *extensionsv1beta1.DeploymentSpec, out *apps.DeploymentSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentSpec_To_apps_DeploymentSpec(in, out, s)
}

func autoConvert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(in *apps.DeploymentSpec, out *extensionsv1beta1.DeploymentSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        if err := Convert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(&in.Strategy, &out.Strategy, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.RevisionHistoryLimit = (*int32)(unsafe.Pointer(in.RevisionHistoryLimit))
        out.Paused = in.Paused
        out.RollbackTo = (*extensionsv1beta1.RollbackConfig)(unsafe.Pointer(in.RollbackTo))
        out.ProgressDeadlineSeconds = (*int32)(unsafe.Pointer(in.ProgressDeadlineSeconds))
        return nil
}

// Convert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec is an autogenerated conversion function.
func Convert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(in *apps.DeploymentSpec, out *extensionsv1beta1.DeploymentSpec, s conversion.Scope) error {
        return autoConvert_apps_DeploymentSpec_To_v1beta1_DeploymentSpec(in, out, s)
}

func autoConvert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(in *extensionsv1beta1.DeploymentStatus, out *apps.DeploymentStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Replicas = in.Replicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.UnavailableReplicas = in.UnavailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.Conditions = *(*[]apps.DeploymentCondition)(unsafe.Pointer(&in.Conditions))
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        return nil
}

// Convert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus is an autogenerated conversion function.
func Convert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(in *extensionsv1beta1.DeploymentStatus, out *apps.DeploymentStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentStatus_To_apps_DeploymentStatus(in, out, s)
}

func autoConvert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(in *apps.DeploymentStatus, out *extensionsv1beta1.DeploymentStatus, s conversion.Scope) error {
        out.ObservedGeneration = in.ObservedGeneration
        out.Replicas = in.Replicas
        out.UpdatedReplicas = in.UpdatedReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.UnavailableReplicas = in.UnavailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.Conditions = *(*[]extensionsv1beta1.DeploymentCondition)(unsafe.Pointer(&in.Conditions))
        out.CollisionCount = (*int32)(unsafe.Pointer(in.CollisionCount))
        return nil
}

// Convert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus is an autogenerated conversion function.
func Convert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(in *apps.DeploymentStatus, out *extensionsv1beta1.DeploymentStatus, s conversion.Scope) error {
        return autoConvert_apps_DeploymentStatus_To_v1beta1_DeploymentStatus(in, out, s)
}

func autoConvert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(in *extensionsv1beta1.DeploymentStrategy, out *apps.DeploymentStrategy, s conversion.Scope) error {
        out.Type = apps.DeploymentStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(apps.RollingUpdateDeployment)
                if err := Convert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy is an autogenerated conversion function.
func Convert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(in *extensionsv1beta1.DeploymentStrategy, out *apps.DeploymentStrategy, s conversion.Scope) error {
        return autoConvert_v1beta1_DeploymentStrategy_To_apps_DeploymentStrategy(in, out, s)
}

func autoConvert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in *apps.DeploymentStrategy, out *extensionsv1beta1.DeploymentStrategy, s conversion.Scope) error {
        out.Type = extensionsv1beta1.DeploymentStrategyType(in.Type)
        if in.RollingUpdate != nil {
                in, out := &in.RollingUpdate, &out.RollingUpdate
                *out = new(extensionsv1beta1.RollingUpdateDeployment)
                if err := Convert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.RollingUpdate = nil
        }
        return nil
}

// Convert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy is an autogenerated conversion function.
func Convert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in *apps.DeploymentStrategy, out *extensionsv1beta1.DeploymentStrategy, s conversion.Scope) error {
        return autoConvert_apps_DeploymentStrategy_To_v1beta1_DeploymentStrategy(in, out, s)
}

func autoConvert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(in *extensionsv1beta1.HTTPIngressPath, out *networking.HTTPIngressPath, s conversion.Scope) error {
        out.Path = in.Path
        out.PathType = (*networking.PathType)(unsafe.Pointer(in.PathType))
        if err := Convert_v1beta1_IngressBackend_To_networking_IngressBackend(&in.Backend, &out.Backend, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath is an autogenerated conversion function.
func Convert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(in *extensionsv1beta1.HTTPIngressPath, out *networking.HTTPIngressPath, s conversion.Scope) error {
        return autoConvert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(in, out, s)
}

func autoConvert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in *networking.HTTPIngressPath, out *extensionsv1beta1.HTTPIngressPath, s conversion.Scope) error {
        out.Path = in.Path
        out.PathType = (*extensionsv1beta1.PathType)(unsafe.Pointer(in.PathType))
        if err := Convert_networking_IngressBackend_To_v1beta1_IngressBackend(&in.Backend, &out.Backend, s); err != nil {
                return err
        }
        return nil
}

// Convert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath is an autogenerated conversion function.
func Convert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in *networking.HTTPIngressPath, out *extensionsv1beta1.HTTPIngressPath, s conversion.Scope) error {
        return autoConvert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(in, out, s)
}

func autoConvert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(in *extensionsv1beta1.HTTPIngressRuleValue, out *networking.HTTPIngressRuleValue, s conversion.Scope) error {
        if in.Paths != nil {
                in, out := &in.Paths, &out.Paths
                *out = make([]networking.HTTPIngressPath, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_HTTPIngressPath_To_networking_HTTPIngressPath(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Paths = nil
        }
        return nil
}

// Convert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue is an autogenerated conversion function.
func Convert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(in *extensionsv1beta1.HTTPIngressRuleValue, out *networking.HTTPIngressRuleValue, s conversion.Scope) error {
        return autoConvert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(in, out, s)
}

func autoConvert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in *networking.HTTPIngressRuleValue, out *extensionsv1beta1.HTTPIngressRuleValue, s conversion.Scope) error {
        if in.Paths != nil {
                in, out := &in.Paths, &out.Paths
                *out = make([]extensionsv1beta1.HTTPIngressPath, len(*in))
                for i := range *in {
                        if err := Convert_networking_HTTPIngressPath_To_v1beta1_HTTPIngressPath(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Paths = nil
        }
        return nil
}

// Convert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue is an autogenerated conversion function.
func Convert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in *networking.HTTPIngressRuleValue, out *extensionsv1beta1.HTTPIngressRuleValue, s conversion.Scope) error {
        return autoConvert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(in, out, s)
}

func autoConvert_v1beta1_IPBlock_To_networking_IPBlock(in *extensionsv1beta1.IPBlock, out *networking.IPBlock, s conversion.Scope) error {
        out.CIDR = in.CIDR
        out.Except = *(*[]string)(unsafe.Pointer(&in.Except))
        return nil
}

func autoConvert_networking_IPBlock_To_v1beta1_IPBlock(in *networking.IPBlock, out *extensionsv1beta1.IPBlock, s conversion.Scope) error {
        out.CIDR = in.CIDR
        out.Except = *(*[]string)(unsafe.Pointer(&in.Except))
        return nil
}

func autoConvert_v1beta1_Ingress_To_networking_Ingress(in *extensionsv1beta1.Ingress, out *networking.Ingress, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_IngressSpec_To_networking_IngressSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_IngressStatus_To_networking_IngressStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_Ingress_To_networking_Ingress is an autogenerated conversion function.
func Convert_v1beta1_Ingress_To_networking_Ingress(in *extensionsv1beta1.Ingress, out *networking.Ingress, s conversion.Scope) error {
        return autoConvert_v1beta1_Ingress_To_networking_Ingress(in, out, s)
}

func autoConvert_networking_Ingress_To_v1beta1_Ingress(in *networking.Ingress, out *extensionsv1beta1.Ingress, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_networking_IngressSpec_To_v1beta1_IngressSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_networking_IngressStatus_To_v1beta1_IngressStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_networking_Ingress_To_v1beta1_Ingress is an autogenerated conversion function.
func Convert_networking_Ingress_To_v1beta1_Ingress(in *networking.Ingress, out *extensionsv1beta1.Ingress, s conversion.Scope) error {
        return autoConvert_networking_Ingress_To_v1beta1_Ingress(in, out, s)
}

func autoConvert_v1beta1_IngressBackend_To_networking_IngressBackend(in *extensionsv1beta1.IngressBackend, out *networking.IngressBackend, s conversion.Scope) error {
        // WARNING: in.ServiceName requires manual conversion: does not exist in peer-type
        // WARNING: in.ServicePort requires manual conversion: does not exist in peer-type
        out.Resource = (*core.TypedLocalObjectReference)(unsafe.Pointer(in.Resource))
        return nil
}

func autoConvert_networking_IngressBackend_To_v1beta1_IngressBackend(in *networking.IngressBackend, out *extensionsv1beta1.IngressBackend, s conversion.Scope) error {
        // WARNING: in.Service requires manual conversion: does not exist in peer-type
        out.Resource = (*v1.TypedLocalObjectReference)(unsafe.Pointer(in.Resource))
        return nil
}

func autoConvert_v1beta1_IngressList_To_networking_IngressList(in *extensionsv1beta1.IngressList, out *networking.IngressList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]networking.Ingress, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_Ingress_To_networking_Ingress(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_IngressList_To_networking_IngressList is an autogenerated conversion function.
func Convert_v1beta1_IngressList_To_networking_IngressList(in *extensionsv1beta1.IngressList, out *networking.IngressList, s conversion.Scope) error {
        return autoConvert_v1beta1_IngressList_To_networking_IngressList(in, out, s)
}

func autoConvert_networking_IngressList_To_v1beta1_IngressList(in *networking.IngressList, out *extensionsv1beta1.IngressList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]extensionsv1beta1.Ingress, len(*in))
                for i := range *in {
                        if err := Convert_networking_Ingress_To_v1beta1_Ingress(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_networking_IngressList_To_v1beta1_IngressList is an autogenerated conversion function.
func Convert_networking_IngressList_To_v1beta1_IngressList(in *networking.IngressList, out *extensionsv1beta1.IngressList, s conversion.Scope) error {
        return autoConvert_networking_IngressList_To_v1beta1_IngressList(in, out, s)
}

func autoConvert_v1beta1_IngressLoadBalancerIngress_To_networking_IngressLoadBalancerIngress(in *extensionsv1beta1.IngressLoadBalancerIngress, out *networking.IngressLoadBalancerIngress, s conversion.Scope) error {
        out.IP = in.IP
        out.Hostname = in.Hostname
        out.Ports = *(*[]networking.IngressPortStatus)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_v1beta1_IngressLoadBalancerIngress_To_networking_IngressLoadBalancerIngress is an autogenerated conversion function.
func Convert_v1beta1_IngressLoadBalancerIngress_To_networking_IngressLoadBalancerIngress(in *extensionsv1beta1.IngressLoadBalancerIngress, out *networking.IngressLoadBalancerIngress, s conversion.Scope) error {
        return autoConvert_v1beta1_IngressLoadBalancerIngress_To_networking_IngressLoadBalancerIngress(in, out, s)
}

func autoConvert_networking_IngressLoadBalancerIngress_To_v1beta1_IngressLoadBalancerIngress(in *networking.IngressLoadBalancerIngress, out *extensionsv1beta1.IngressLoadBalancerIngress, s conversion.Scope) error {
        out.IP = in.IP
        out.Hostname = in.Hostname
        out.Ports = *(*[]extensionsv1beta1.IngressPortStatus)(unsafe.Pointer(&in.Ports))
        return nil
}

// Convert_networking_IngressLoadBalancerIngress_To_v1beta1_IngressLoadBalancerIngress is an autogenerated conversion function.
func Convert_networking_IngressLoadBalancerIngress_To_v1beta1_IngressLoadBalancerIngress(in *networking.IngressLoadBalancerIngress, out *extensionsv1beta1.IngressLoadBalancerIngress, s conversion.Scope) error {
        return autoConvert_networking_IngressLoadBalancerIngress_To_v1beta1_IngressLoadBalancerIngress(in, out, s)
}

func autoConvert_v1beta1_IngressLoadBalancerStatus_To_networking_IngressLoadBalancerStatus(in *extensionsv1beta1.IngressLoadBalancerStatus, out *networking.IngressLoadBalancerStatus, s conversion.Scope) error {
        out.Ingress = *(*[]networking.IngressLoadBalancerIngress)(unsafe.Pointer(&in.Ingress))
        return nil
}

// Convert_v1beta1_IngressLoadBalancerStatus_To_networking_IngressLoadBalancerStatus is an autogenerated conversion function.
func Convert_v1beta1_IngressLoadBalancerStatus_To_networking_IngressLoadBalancerStatus(in *extensionsv1beta1.IngressLoadBalancerStatus, out *networking.IngressLoadBalancerStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_IngressLoadBalancerStatus_To_networking_IngressLoadBalancerStatus(in, out, s)
}

func autoConvert_networking_IngressLoadBalancerStatus_To_v1beta1_IngressLoadBalancerStatus(in *networking.IngressLoadBalancerStatus, out *extensionsv1beta1.IngressLoadBalancerStatus, s conversion.Scope) error {
        out.Ingress = *(*[]extensionsv1beta1.IngressLoadBalancerIngress)(unsafe.Pointer(&in.Ingress))
        return nil
}

// Convert_networking_IngressLoadBalancerStatus_To_v1beta1_IngressLoadBalancerStatus is an autogenerated conversion function.
func Convert_networking_IngressLoadBalancerStatus_To_v1beta1_IngressLoadBalancerStatus(in *networking.IngressLoadBalancerStatus, out *extensionsv1beta1.IngressLoadBalancerStatus, s conversion.Scope) error {
        return autoConvert_networking_IngressLoadBalancerStatus_To_v1beta1_IngressLoadBalancerStatus(in, out, s)
}

func autoConvert_v1beta1_IngressPortStatus_To_networking_IngressPortStatus(in *extensionsv1beta1.IngressPortStatus, out *networking.IngressPortStatus, s conversion.Scope) error {
        out.Port = in.Port
        out.Protocol = core.Protocol(in.Protocol)
        out.Error = (*string)(unsafe.Pointer(in.Error))
        return nil
}

// Convert_v1beta1_IngressPortStatus_To_networking_IngressPortStatus is an autogenerated conversion function.
func Convert_v1beta1_IngressPortStatus_To_networking_IngressPortStatus(in *extensionsv1beta1.IngressPortStatus, out *networking.IngressPortStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_IngressPortStatus_To_networking_IngressPortStatus(in, out, s)
}

func autoConvert_networking_IngressPortStatus_To_v1beta1_IngressPortStatus(in *networking.IngressPortStatus, out *extensionsv1beta1.IngressPortStatus, s conversion.Scope) error {
        out.Port = in.Port
        out.Protocol = v1.Protocol(in.Protocol)
        out.Error = (*string)(unsafe.Pointer(in.Error))
        return nil
}

// Convert_networking_IngressPortStatus_To_v1beta1_IngressPortStatus is an autogenerated conversion function.
func Convert_networking_IngressPortStatus_To_v1beta1_IngressPortStatus(in *networking.IngressPortStatus, out *extensionsv1beta1.IngressPortStatus, s conversion.Scope) error {
        return autoConvert_networking_IngressPortStatus_To_v1beta1_IngressPortStatus(in, out, s)
}

func autoConvert_v1beta1_IngressRule_To_networking_IngressRule(in *extensionsv1beta1.IngressRule, out *networking.IngressRule, s conversion.Scope) error {
        out.Host = in.Host
        if err := Convert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_IngressRule_To_networking_IngressRule is an autogenerated conversion function.
func Convert_v1beta1_IngressRule_To_networking_IngressRule(in *extensionsv1beta1.IngressRule, out *networking.IngressRule, s conversion.Scope) error {
        return autoConvert_v1beta1_IngressRule_To_networking_IngressRule(in, out, s)
}

func autoConvert_networking_IngressRule_To_v1beta1_IngressRule(in *networking.IngressRule, out *extensionsv1beta1.IngressRule, s conversion.Scope) error {
        out.Host = in.Host
        if err := Convert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil {
                return err
        }
        return nil
}

// Convert_networking_IngressRule_To_v1beta1_IngressRule is an autogenerated conversion function.
func Convert_networking_IngressRule_To_v1beta1_IngressRule(in *networking.IngressRule, out *extensionsv1beta1.IngressRule, s conversion.Scope) error {
        return autoConvert_networking_IngressRule_To_v1beta1_IngressRule(in, out, s)
}

func autoConvert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(in *extensionsv1beta1.IngressRuleValue, out *networking.IngressRuleValue, s conversion.Scope) error {
        if in.HTTP != nil {
                in, out := &in.HTTP, &out.HTTP
                *out = new(networking.HTTPIngressRuleValue)
                if err := Convert_v1beta1_HTTPIngressRuleValue_To_networking_HTTPIngressRuleValue(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.HTTP = nil
        }
        return nil
}

// Convert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue is an autogenerated conversion function.
func Convert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(in *extensionsv1beta1.IngressRuleValue, out *networking.IngressRuleValue, s conversion.Scope) error {
        return autoConvert_v1beta1_IngressRuleValue_To_networking_IngressRuleValue(in, out, s)
}

func autoConvert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(in *networking.IngressRuleValue, out *extensionsv1beta1.IngressRuleValue, s conversion.Scope) error {
        if in.HTTP != nil {
                in, out := &in.HTTP, &out.HTTP
                *out = new(extensionsv1beta1.HTTPIngressRuleValue)
                if err := Convert_networking_HTTPIngressRuleValue_To_v1beta1_HTTPIngressRuleValue(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.HTTP = nil
        }
        return nil
}

// Convert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue is an autogenerated conversion function.
func Convert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(in *networking.IngressRuleValue, out *extensionsv1beta1.IngressRuleValue, s conversion.Scope) error {
        return autoConvert_networking_IngressRuleValue_To_v1beta1_IngressRuleValue(in, out, s)
}

func autoConvert_v1beta1_IngressSpec_To_networking_IngressSpec(in *extensionsv1beta1.IngressSpec, out *networking.IngressSpec, s conversion.Scope) error {
        out.IngressClassName = (*string)(unsafe.Pointer(in.IngressClassName))
        // WARNING: in.Backend requires manual conversion: does not exist in peer-type
        out.TLS = *(*[]networking.IngressTLS)(unsafe.Pointer(&in.TLS))
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]networking.IngressRule, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_IngressRule_To_networking_IngressRule(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        return nil
}

func autoConvert_networking_IngressSpec_To_v1beta1_IngressSpec(in *networking.IngressSpec, out *extensionsv1beta1.IngressSpec, s conversion.Scope) error {
        out.IngressClassName = (*string)(unsafe.Pointer(in.IngressClassName))
        // WARNING: in.DefaultBackend requires manual conversion: does not exist in peer-type
        out.TLS = *(*[]extensionsv1beta1.IngressTLS)(unsafe.Pointer(&in.TLS))
        if in.Rules != nil {
                in, out := &in.Rules, &out.Rules
                *out = make([]extensionsv1beta1.IngressRule, len(*in))
                for i := range *in {
                        if err := Convert_networking_IngressRule_To_v1beta1_IngressRule(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Rules = nil
        }
        return nil
}

func autoConvert_v1beta1_IngressStatus_To_networking_IngressStatus(in *extensionsv1beta1.IngressStatus, out *networking.IngressStatus, s conversion.Scope) error {
        if err := Convert_v1beta1_IngressLoadBalancerStatus_To_networking_IngressLoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_IngressStatus_To_networking_IngressStatus is an autogenerated conversion function.
func Convert_v1beta1_IngressStatus_To_networking_IngressStatus(in *extensionsv1beta1.IngressStatus, out *networking.IngressStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_IngressStatus_To_networking_IngressStatus(in, out, s)
}

func autoConvert_networking_IngressStatus_To_v1beta1_IngressStatus(in *networking.IngressStatus, out *extensionsv1beta1.IngressStatus, s conversion.Scope) error {
        if err := Convert_networking_IngressLoadBalancerStatus_To_v1beta1_IngressLoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, s); err != nil {
                return err
        }
        return nil
}

// Convert_networking_IngressStatus_To_v1beta1_IngressStatus is an autogenerated conversion function.
func Convert_networking_IngressStatus_To_v1beta1_IngressStatus(in *networking.IngressStatus, out *extensionsv1beta1.IngressStatus, s conversion.Scope) error {
        return autoConvert_networking_IngressStatus_To_v1beta1_IngressStatus(in, out, s)
}

func autoConvert_v1beta1_IngressTLS_To_networking_IngressTLS(in *extensionsv1beta1.IngressTLS, out *networking.IngressTLS, s conversion.Scope) error {
        out.Hosts = *(*[]string)(unsafe.Pointer(&in.Hosts))
        out.SecretName = in.SecretName
        return nil
}

// Convert_v1beta1_IngressTLS_To_networking_IngressTLS is an autogenerated conversion function.
func Convert_v1beta1_IngressTLS_To_networking_IngressTLS(in *extensionsv1beta1.IngressTLS, out *networking.IngressTLS, s conversion.Scope) error {
        return autoConvert_v1beta1_IngressTLS_To_networking_IngressTLS(in, out, s)
}

func autoConvert_networking_IngressTLS_To_v1beta1_IngressTLS(in *networking.IngressTLS, out *extensionsv1beta1.IngressTLS, s conversion.Scope) error {
        out.Hosts = *(*[]string)(unsafe.Pointer(&in.Hosts))
        out.SecretName = in.SecretName
        return nil
}

// Convert_networking_IngressTLS_To_v1beta1_IngressTLS is an autogenerated conversion function.
func Convert_networking_IngressTLS_To_v1beta1_IngressTLS(in *networking.IngressTLS, out *extensionsv1beta1.IngressTLS, s conversion.Scope) error {
        return autoConvert_networking_IngressTLS_To_v1beta1_IngressTLS(in, out, s)
}

func autoConvert_v1beta1_NetworkPolicy_To_networking_NetworkPolicy(in *extensionsv1beta1.NetworkPolicy, out *networking.NetworkPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_NetworkPolicySpec_To_networking_NetworkPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_NetworkPolicy_To_networking_NetworkPolicy is an autogenerated conversion function.
func Convert_v1beta1_NetworkPolicy_To_networking_NetworkPolicy(in *extensionsv1beta1.NetworkPolicy, out *networking.NetworkPolicy, s conversion.Scope) error {
        return autoConvert_v1beta1_NetworkPolicy_To_networking_NetworkPolicy(in, out, s)
}

func autoConvert_networking_NetworkPolicy_To_v1beta1_NetworkPolicy(in *networking.NetworkPolicy, out *extensionsv1beta1.NetworkPolicy, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_networking_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        return nil
}

// Convert_networking_NetworkPolicy_To_v1beta1_NetworkPolicy is an autogenerated conversion function.
func Convert_networking_NetworkPolicy_To_v1beta1_NetworkPolicy(in *networking.NetworkPolicy, out *extensionsv1beta1.NetworkPolicy, s conversion.Scope) error {
        return autoConvert_networking_NetworkPolicy_To_v1beta1_NetworkPolicy(in, out, s)
}

func autoConvert_v1beta1_NetworkPolicyEgressRule_To_networking_NetworkPolicyEgressRule(in *extensionsv1beta1.NetworkPolicyEgressRule, out *networking.NetworkPolicyEgressRule, s conversion.Scope) error {
        out.Ports = *(*[]networking.NetworkPolicyPort)(unsafe.Pointer(&in.Ports))
        if in.To != nil {
                in, out := &in.To, &out.To
                *out = make([]networking.NetworkPolicyPeer, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_NetworkPolicyPeer_To_networking_NetworkPolicyPeer(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.To = nil
        }
        return nil
}

func autoConvert_networking_NetworkPolicyEgressRule_To_v1beta1_NetworkPolicyEgressRule(in *networking.NetworkPolicyEgressRule, out *extensionsv1beta1.NetworkPolicyEgressRule, s conversion.Scope) error {
        out.Ports = *(*[]extensionsv1beta1.NetworkPolicyPort)(unsafe.Pointer(&in.Ports))
        if in.To != nil {
                in, out := &in.To, &out.To
                *out = make([]extensionsv1beta1.NetworkPolicyPeer, len(*in))
                for i := range *in {
                        if err := Convert_networking_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.To = nil
        }
        return nil
}

func autoConvert_v1beta1_NetworkPolicyIngressRule_To_networking_NetworkPolicyIngressRule(in *extensionsv1beta1.NetworkPolicyIngressRule, out *networking.NetworkPolicyIngressRule, s conversion.Scope) error {
        out.Ports = *(*[]networking.NetworkPolicyPort)(unsafe.Pointer(&in.Ports))
        if in.From != nil {
                in, out := &in.From, &out.From
                *out = make([]networking.NetworkPolicyPeer, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_NetworkPolicyPeer_To_networking_NetworkPolicyPeer(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.From = nil
        }
        return nil
}

func autoConvert_networking_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(in *networking.NetworkPolicyIngressRule, out *extensionsv1beta1.NetworkPolicyIngressRule, s conversion.Scope) error {
        out.Ports = *(*[]extensionsv1beta1.NetworkPolicyPort)(unsafe.Pointer(&in.Ports))
        if in.From != nil {
                in, out := &in.From, &out.From
                *out = make([]extensionsv1beta1.NetworkPolicyPeer, len(*in))
                for i := range *in {
                        if err := Convert_networking_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.From = nil
        }
        return nil
}

func autoConvert_v1beta1_NetworkPolicyList_To_networking_NetworkPolicyList(in *extensionsv1beta1.NetworkPolicyList, out *networking.NetworkPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]networking.NetworkPolicy, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_NetworkPolicy_To_networking_NetworkPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_NetworkPolicyList_To_networking_NetworkPolicyList is an autogenerated conversion function.
func Convert_v1beta1_NetworkPolicyList_To_networking_NetworkPolicyList(in *extensionsv1beta1.NetworkPolicyList, out *networking.NetworkPolicyList, s conversion.Scope) error {
        return autoConvert_v1beta1_NetworkPolicyList_To_networking_NetworkPolicyList(in, out, s)
}

func autoConvert_networking_NetworkPolicyList_To_v1beta1_NetworkPolicyList(in *networking.NetworkPolicyList, out *extensionsv1beta1.NetworkPolicyList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]extensionsv1beta1.NetworkPolicy, len(*in))
                for i := range *in {
                        if err := Convert_networking_NetworkPolicy_To_v1beta1_NetworkPolicy(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_networking_NetworkPolicyList_To_v1beta1_NetworkPolicyList is an autogenerated conversion function.
func Convert_networking_NetworkPolicyList_To_v1beta1_NetworkPolicyList(in *networking.NetworkPolicyList, out *extensionsv1beta1.NetworkPolicyList, s conversion.Scope) error {
        return autoConvert_networking_NetworkPolicyList_To_v1beta1_NetworkPolicyList(in, out, s)
}

func autoConvert_v1beta1_NetworkPolicyPeer_To_networking_NetworkPolicyPeer(in *extensionsv1beta1.NetworkPolicyPeer, out *networking.NetworkPolicyPeer, s conversion.Scope) error {
        out.PodSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.PodSelector))
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        if in.IPBlock != nil {
                in, out := &in.IPBlock, &out.IPBlock
                *out = new(networking.IPBlock)
                if err := Convert_v1beta1_IPBlock_To_networking_IPBlock(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.IPBlock = nil
        }
        return nil
}

// Convert_v1beta1_NetworkPolicyPeer_To_networking_NetworkPolicyPeer is an autogenerated conversion function.
func Convert_v1beta1_NetworkPolicyPeer_To_networking_NetworkPolicyPeer(in *extensionsv1beta1.NetworkPolicyPeer, out *networking.NetworkPolicyPeer, s conversion.Scope) error {
        return autoConvert_v1beta1_NetworkPolicyPeer_To_networking_NetworkPolicyPeer(in, out, s)
}

func autoConvert_networking_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(in *networking.NetworkPolicyPeer, out *extensionsv1beta1.NetworkPolicyPeer, s conversion.Scope) error {
        out.PodSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.PodSelector))
        out.NamespaceSelector = (*metav1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
        if in.IPBlock != nil {
                in, out := &in.IPBlock, &out.IPBlock
                *out = new(extensionsv1beta1.IPBlock)
                if err := Convert_networking_IPBlock_To_v1beta1_IPBlock(*in, *out, s); err != nil {
                        return err
                }
        } else {
                out.IPBlock = nil
        }
        return nil
}

// Convert_networking_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer is an autogenerated conversion function.
func Convert_networking_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(in *networking.NetworkPolicyPeer, out *extensionsv1beta1.NetworkPolicyPeer, s conversion.Scope) error {
        return autoConvert_networking_NetworkPolicyPeer_To_v1beta1_NetworkPolicyPeer(in, out, s)
}

func autoConvert_v1beta1_NetworkPolicyPort_To_networking_NetworkPolicyPort(in *extensionsv1beta1.NetworkPolicyPort, out *networking.NetworkPolicyPort, s conversion.Scope) error {
        out.Protocol = (*core.Protocol)(unsafe.Pointer(in.Protocol))
        out.Port = (*intstr.IntOrString)(unsafe.Pointer(in.Port))
        out.EndPort = (*int32)(unsafe.Pointer(in.EndPort))
        return nil
}

// Convert_v1beta1_NetworkPolicyPort_To_networking_NetworkPolicyPort is an autogenerated conversion function.
func Convert_v1beta1_NetworkPolicyPort_To_networking_NetworkPolicyPort(in *extensionsv1beta1.NetworkPolicyPort, out *networking.NetworkPolicyPort, s conversion.Scope) error {
        return autoConvert_v1beta1_NetworkPolicyPort_To_networking_NetworkPolicyPort(in, out, s)
}

func autoConvert_networking_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort(in *networking.NetworkPolicyPort, out *extensionsv1beta1.NetworkPolicyPort, s conversion.Scope) error {
        out.Protocol = (*v1.Protocol)(unsafe.Pointer(in.Protocol))
        out.Port = (*intstr.IntOrString)(unsafe.Pointer(in.Port))
        out.EndPort = (*int32)(unsafe.Pointer(in.EndPort))
        return nil
}

// Convert_networking_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort is an autogenerated conversion function.
func Convert_networking_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort(in *networking.NetworkPolicyPort, out *extensionsv1beta1.NetworkPolicyPort, s conversion.Scope) error {
        return autoConvert_networking_NetworkPolicyPort_To_v1beta1_NetworkPolicyPort(in, out, s)
}

func autoConvert_v1beta1_NetworkPolicySpec_To_networking_NetworkPolicySpec(in *extensionsv1beta1.NetworkPolicySpec, out *networking.NetworkPolicySpec, s conversion.Scope) error {
        out.PodSelector = in.PodSelector
        if in.Ingress != nil {
                in, out := &in.Ingress, &out.Ingress
                *out = make([]networking.NetworkPolicyIngressRule, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_NetworkPolicyIngressRule_To_networking_NetworkPolicyIngressRule(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Ingress = nil
        }
        if in.Egress != nil {
                in, out := &in.Egress, &out.Egress
                *out = make([]networking.NetworkPolicyEgressRule, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_NetworkPolicyEgressRule_To_networking_NetworkPolicyEgressRule(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Egress = nil
        }
        out.PolicyTypes = *(*[]networking.PolicyType)(unsafe.Pointer(&in.PolicyTypes))
        return nil
}

func autoConvert_networking_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(in *networking.NetworkPolicySpec, out *extensionsv1beta1.NetworkPolicySpec, s conversion.Scope) error {
        out.PodSelector = in.PodSelector
        if in.Ingress != nil {
                in, out := &in.Ingress, &out.Ingress
                *out = make([]extensionsv1beta1.NetworkPolicyIngressRule, len(*in))
                for i := range *in {
                        if err := Convert_networking_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Ingress = nil
        }
        if in.Egress != nil {
                in, out := &in.Egress, &out.Egress
                *out = make([]extensionsv1beta1.NetworkPolicyEgressRule, len(*in))
                for i := range *in {
                        if err := Convert_networking_NetworkPolicyEgressRule_To_v1beta1_NetworkPolicyEgressRule(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Egress = nil
        }
        out.PolicyTypes = *(*[]extensionsv1beta1.PolicyType)(unsafe.Pointer(&in.PolicyTypes))
        return nil
}

func autoConvert_v1beta1_ReplicaSet_To_apps_ReplicaSet(in *extensionsv1beta1.ReplicaSet, out *apps.ReplicaSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_ReplicaSetSpec_To_apps_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_ReplicaSetStatus_To_apps_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_ReplicaSet_To_apps_ReplicaSet is an autogenerated conversion function.
func Convert_v1beta1_ReplicaSet_To_apps_ReplicaSet(in *extensionsv1beta1.ReplicaSet, out *apps.ReplicaSet, s conversion.Scope) error {
        return autoConvert_v1beta1_ReplicaSet_To_apps_ReplicaSet(in, out, s)
}

func autoConvert_apps_ReplicaSet_To_v1beta1_ReplicaSet(in *apps.ReplicaSet, out *extensionsv1beta1.ReplicaSet, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_apps_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_apps_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_ReplicaSet_To_v1beta1_ReplicaSet is an autogenerated conversion function.
func Convert_apps_ReplicaSet_To_v1beta1_ReplicaSet(in *apps.ReplicaSet, out *extensionsv1beta1.ReplicaSet, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSet_To_v1beta1_ReplicaSet(in, out, s)
}

func autoConvert_v1beta1_ReplicaSetCondition_To_apps_ReplicaSetCondition(in *extensionsv1beta1.ReplicaSetCondition, out *apps.ReplicaSetCondition, s conversion.Scope) error {
        out.Type = apps.ReplicaSetConditionType(in.Type)
        out.Status = core.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1beta1_ReplicaSetCondition_To_apps_ReplicaSetCondition is an autogenerated conversion function.
func Convert_v1beta1_ReplicaSetCondition_To_apps_ReplicaSetCondition(in *extensionsv1beta1.ReplicaSetCondition, out *apps.ReplicaSetCondition, s conversion.Scope) error {
        return autoConvert_v1beta1_ReplicaSetCondition_To_apps_ReplicaSetCondition(in, out, s)
}

func autoConvert_apps_ReplicaSetCondition_To_v1beta1_ReplicaSetCondition(in *apps.ReplicaSetCondition, out *extensionsv1beta1.ReplicaSetCondition, s conversion.Scope) error {
        out.Type = extensionsv1beta1.ReplicaSetConditionType(in.Type)
        out.Status = v1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_apps_ReplicaSetCondition_To_v1beta1_ReplicaSetCondition is an autogenerated conversion function.
func Convert_apps_ReplicaSetCondition_To_v1beta1_ReplicaSetCondition(in *apps.ReplicaSetCondition, out *extensionsv1beta1.ReplicaSetCondition, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetCondition_To_v1beta1_ReplicaSetCondition(in, out, s)
}

func autoConvert_v1beta1_ReplicaSetList_To_apps_ReplicaSetList(in *extensionsv1beta1.ReplicaSetList, out *apps.ReplicaSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]apps.ReplicaSet, len(*in))
                for i := range *in {
                        if err := Convert_v1beta1_ReplicaSet_To_apps_ReplicaSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_v1beta1_ReplicaSetList_To_apps_ReplicaSetList is an autogenerated conversion function.
func Convert_v1beta1_ReplicaSetList_To_apps_ReplicaSetList(in *extensionsv1beta1.ReplicaSetList, out *apps.ReplicaSetList, s conversion.Scope) error {
        return autoConvert_v1beta1_ReplicaSetList_To_apps_ReplicaSetList(in, out, s)
}

func autoConvert_apps_ReplicaSetList_To_v1beta1_ReplicaSetList(in *apps.ReplicaSetList, out *extensionsv1beta1.ReplicaSetList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        if in.Items != nil {
                in, out := &in.Items, &out.Items
                *out = make([]extensionsv1beta1.ReplicaSet, len(*in))
                for i := range *in {
                        if err := Convert_apps_ReplicaSet_To_v1beta1_ReplicaSet(&(*in)[i], &(*out)[i], s); err != nil {
                                return err
                        }
                }
        } else {
                out.Items = nil
        }
        return nil
}

// Convert_apps_ReplicaSetList_To_v1beta1_ReplicaSetList is an autogenerated conversion function.
func Convert_apps_ReplicaSetList_To_v1beta1_ReplicaSetList(in *apps.ReplicaSetList, out *extensionsv1beta1.ReplicaSetList, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetList_To_v1beta1_ReplicaSetList(in, out, s)
}

func autoConvert_v1beta1_ReplicaSetSpec_To_apps_ReplicaSetSpec(in *extensionsv1beta1.ReplicaSetSpec, out *apps.ReplicaSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_v1_PodTemplateSpec_To_core_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_ReplicaSetSpec_To_apps_ReplicaSetSpec is an autogenerated conversion function.
func Convert_v1beta1_ReplicaSetSpec_To_apps_ReplicaSetSpec(in *extensionsv1beta1.ReplicaSetSpec, out *apps.ReplicaSetSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_ReplicaSetSpec_To_apps_ReplicaSetSpec(in, out, s)
}

func autoConvert_apps_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(in *apps.ReplicaSetSpec, out *extensionsv1beta1.ReplicaSetSpec, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
                return err
        }
        out.MinReadySeconds = in.MinReadySeconds
        out.Selector = (*metav1.LabelSelector)(unsafe.Pointer(in.Selector))
        if err := corev1.Convert_core_PodTemplateSpec_To_v1_PodTemplateSpec(&in.Template, &out.Template, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec is an autogenerated conversion function.
func Convert_apps_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(in *apps.ReplicaSetSpec, out *extensionsv1beta1.ReplicaSetSpec, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetSpec_To_v1beta1_ReplicaSetSpec(in, out, s)
}

func autoConvert_v1beta1_ReplicaSetStatus_To_apps_ReplicaSetStatus(in *extensionsv1beta1.ReplicaSetStatus, out *apps.ReplicaSetStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.ObservedGeneration = in.ObservedGeneration
        out.Conditions = *(*[]apps.ReplicaSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1beta1_ReplicaSetStatus_To_apps_ReplicaSetStatus is an autogenerated conversion function.
func Convert_v1beta1_ReplicaSetStatus_To_apps_ReplicaSetStatus(in *extensionsv1beta1.ReplicaSetStatus, out *apps.ReplicaSetStatus, s conversion.Scope) error {
        return autoConvert_v1beta1_ReplicaSetStatus_To_apps_ReplicaSetStatus(in, out, s)
}

func autoConvert_apps_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in *apps.ReplicaSetStatus, out *extensionsv1beta1.ReplicaSetStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        out.FullyLabeledReplicas = in.FullyLabeledReplicas
        out.ReadyReplicas = in.ReadyReplicas
        out.AvailableReplicas = in.AvailableReplicas
        out.TerminatingReplicas = (*int32)(unsafe.Pointer(in.TerminatingReplicas))
        out.ObservedGeneration = in.ObservedGeneration
        out.Conditions = *(*[]extensionsv1beta1.ReplicaSetCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_apps_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus is an autogenerated conversion function.
func Convert_apps_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in *apps.ReplicaSetStatus, out *extensionsv1beta1.ReplicaSetStatus, s conversion.Scope) error {
        return autoConvert_apps_ReplicaSetStatus_To_v1beta1_ReplicaSetStatus(in, out, s)
}

func autoConvert_v1beta1_RollbackConfig_To_apps_RollbackConfig(in *extensionsv1beta1.RollbackConfig, out *apps.RollbackConfig, s conversion.Scope) error {
        out.Revision = in.Revision
        return nil
}

// Convert_v1beta1_RollbackConfig_To_apps_RollbackConfig is an autogenerated conversion function.
func Convert_v1beta1_RollbackConfig_To_apps_RollbackConfig(in *extensionsv1beta1.RollbackConfig, out *apps.RollbackConfig, s conversion.Scope) error {
        return autoConvert_v1beta1_RollbackConfig_To_apps_RollbackConfig(in, out, s)
}

func autoConvert_apps_RollbackConfig_To_v1beta1_RollbackConfig(in *apps.RollbackConfig, out *extensionsv1beta1.RollbackConfig, s conversion.Scope) error {
        out.Revision = in.Revision
        return nil
}

// Convert_apps_RollbackConfig_To_v1beta1_RollbackConfig is an autogenerated conversion function.
func Convert_apps_RollbackConfig_To_v1beta1_RollbackConfig(in *apps.RollbackConfig, out *extensionsv1beta1.RollbackConfig, s conversion.Scope) error {
        return autoConvert_apps_RollbackConfig_To_v1beta1_RollbackConfig(in, out, s)
}

func autoConvert_v1beta1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in *extensionsv1beta1.RollingUpdateDaemonSet, out *apps.RollingUpdateDaemonSet, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet is an autogenerated conversion function.
func Convert_v1beta1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in *extensionsv1beta1.RollingUpdateDaemonSet, out *apps.RollingUpdateDaemonSet, s conversion.Scope) error {
        return autoConvert_v1beta1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in, out, s)
}

func autoConvert_apps_RollingUpdateDaemonSet_To_v1beta1_RollingUpdateDaemonSet(in *apps.RollingUpdateDaemonSet, out *extensionsv1beta1.RollingUpdateDaemonSet, s conversion.Scope) error {
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_RollingUpdateDaemonSet_To_v1beta1_RollingUpdateDaemonSet is an autogenerated conversion function.
func Convert_apps_RollingUpdateDaemonSet_To_v1beta1_RollingUpdateDaemonSet(in *apps.RollingUpdateDaemonSet, out *extensionsv1beta1.RollingUpdateDaemonSet, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateDaemonSet_To_v1beta1_RollingUpdateDaemonSet(in, out, s)
}

func autoConvert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in *extensionsv1beta1.RollingUpdateDeployment, out *apps.RollingUpdateDeployment, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment is an autogenerated conversion function.
func Convert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in *extensionsv1beta1.RollingUpdateDeployment, out *apps.RollingUpdateDeployment, s conversion.Scope) error {
        return autoConvert_v1beta1_RollingUpdateDeployment_To_apps_RollingUpdateDeployment(in, out, s)
}

func autoConvert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in *apps.RollingUpdateDeployment, out *extensionsv1beta1.RollingUpdateDeployment, s conversion.Scope) error {
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
                return err
        }
        if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
                return err
        }
        return nil
}

// Convert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment is an autogenerated conversion function.
func Convert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in *apps.RollingUpdateDeployment, out *extensionsv1beta1.RollingUpdateDeployment, s conversion.Scope) error {
        return autoConvert_apps_RollingUpdateDeployment_To_v1beta1_RollingUpdateDeployment(in, out, s)
}

func autoConvert_v1beta1_Scale_To_autoscaling_Scale(in *extensionsv1beta1.Scale, out *autoscaling.Scale, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1beta1_Scale_To_autoscaling_Scale is an autogenerated conversion function.
func Convert_v1beta1_Scale_To_autoscaling_Scale(in *extensionsv1beta1.Scale, out *autoscaling.Scale, s conversion.Scope) error {
        return autoConvert_v1beta1_Scale_To_autoscaling_Scale(in, out, s)
}

func autoConvert_autoscaling_Scale_To_v1beta1_Scale(in *autoscaling.Scale, out *extensionsv1beta1.Scale, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_autoscaling_Scale_To_v1beta1_Scale is an autogenerated conversion function.
func Convert_autoscaling_Scale_To_v1beta1_Scale(in *autoscaling.Scale, out *extensionsv1beta1.Scale, s conversion.Scope) error {
        return autoConvert_autoscaling_Scale_To_v1beta1_Scale(in, out, s)
}

func autoConvert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(in *extensionsv1beta1.ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
        out.Replicas = in.Replicas
        return nil
}

// Convert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec is an autogenerated conversion function.
func Convert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(in *extensionsv1beta1.ScaleSpec, out *autoscaling.ScaleSpec, s conversion.Scope) error {
        return autoConvert_v1beta1_ScaleSpec_To_autoscaling_ScaleSpec(in, out, s)
}

func autoConvert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(in *autoscaling.ScaleSpec, out *extensionsv1beta1.ScaleSpec, s conversion.Scope) error {
        out.Replicas = in.Replicas
        return nil
}

// Convert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec is an autogenerated conversion function.
func Convert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(in *autoscaling.ScaleSpec, out *extensionsv1beta1.ScaleSpec, s conversion.Scope) error {
        return autoConvert_autoscaling_ScaleSpec_To_v1beta1_ScaleSpec(in, out, s)
}

func autoConvert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(in *extensionsv1beta1.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        // WARNING: in.Selector requires manual conversion: inconvertible types (map[string]string vs string)
        // WARNING: in.TargetSelector requires manual conversion: does not exist in peer-type
        return nil
}

func autoConvert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(in *autoscaling.ScaleStatus, out *extensionsv1beta1.ScaleStatus, s conversion.Scope) error {
        out.Replicas = in.Replicas
        // WARNING: in.Selector requires manual conversion: inconvertible types (string vs map[string]string)
        return nil
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 defaulter-gen. DO NOT EDIT.

package v1beta1

import (
        v1 "k8s.io/api/core/v1"
        extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
        runtime "k8s.io/apimachinery/pkg/runtime"
        corev1 "k8s.io/kubernetes/pkg/apis/core/v1"
)

// RegisterDefaults adds defaulters functions to the given scheme.
// Public to allow building arbitrary schemes.
// All generated defaulters are covering - they call all nested defaulters.
func RegisterDefaults(scheme *runtime.Scheme) error {
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.DaemonSet{}, func(obj interface{}) { SetObjectDefaults_DaemonSet(obj.(*extensionsv1beta1.DaemonSet)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.DaemonSetList{}, func(obj interface{}) { SetObjectDefaults_DaemonSetList(obj.(*extensionsv1beta1.DaemonSetList)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.Deployment{}, func(obj interface{}) { SetObjectDefaults_Deployment(obj.(*extensionsv1beta1.Deployment)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.DeploymentList{}, func(obj interface{}) { SetObjectDefaults_DeploymentList(obj.(*extensionsv1beta1.DeploymentList)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.Ingress{}, func(obj interface{}) { SetObjectDefaults_Ingress(obj.(*extensionsv1beta1.Ingress)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.IngressList{}, func(obj interface{}) { SetObjectDefaults_IngressList(obj.(*extensionsv1beta1.IngressList)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.NetworkPolicy{}, func(obj interface{}) { SetObjectDefaults_NetworkPolicy(obj.(*extensionsv1beta1.NetworkPolicy)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.NetworkPolicyList{}, func(obj interface{}) { SetObjectDefaults_NetworkPolicyList(obj.(*extensionsv1beta1.NetworkPolicyList)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.ReplicaSet{}, func(obj interface{}) { SetObjectDefaults_ReplicaSet(obj.(*extensionsv1beta1.ReplicaSet)) })
        scheme.AddTypeDefaultingFunc(&extensionsv1beta1.ReplicaSetList{}, func(obj interface{}) { SetObjectDefaults_ReplicaSetList(obj.(*extensionsv1beta1.ReplicaSetList)) })
        return nil
}

func SetObjectDefaults_DaemonSet(in *extensionsv1beta1.DaemonSet) {
        SetDefaults_DaemonSet(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_DaemonSetList(in *extensionsv1beta1.DaemonSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_DaemonSet(a)
        }
}

func SetObjectDefaults_Deployment(in *extensionsv1beta1.Deployment) {
        SetDefaults_Deployment(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_DeploymentList(in *extensionsv1beta1.DeploymentList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Deployment(a)
        }
}

func SetObjectDefaults_Ingress(in *extensionsv1beta1.Ingress) {
        for i := range in.Spec.Rules {
                a := &in.Spec.Rules[i]
                if a.IngressRuleValue.HTTP != nil {
                        for j := range a.IngressRuleValue.HTTP.Paths {
                                b := &a.IngressRuleValue.HTTP.Paths[j]
                                SetDefaults_HTTPIngressPath(b)
                        }
                }
        }
}

func SetObjectDefaults_IngressList(in *extensionsv1beta1.IngressList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_Ingress(a)
        }
}

func SetObjectDefaults_NetworkPolicy(in *extensionsv1beta1.NetworkPolicy) {
        SetDefaults_NetworkPolicy(in)
}

func SetObjectDefaults_NetworkPolicyList(in *extensionsv1beta1.NetworkPolicyList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_NetworkPolicy(a)
        }
}

func SetObjectDefaults_ReplicaSet(in *extensionsv1beta1.ReplicaSet) {
        SetDefaults_ReplicaSet(in)
        corev1.SetDefaults_PodSpec(&in.Spec.Template.Spec)
        for i := range in.Spec.Template.Spec.Volumes {
                a := &in.Spec.Template.Spec.Volumes[i]
                corev1.SetDefaults_Volume(a)
                if a.VolumeSource.HostPath != nil {
                        corev1.SetDefaults_HostPathVolumeSource(a.VolumeSource.HostPath)
                }
                if a.VolumeSource.Secret != nil {
                        corev1.SetDefaults_SecretVolumeSource(a.VolumeSource.Secret)
                }
                if a.VolumeSource.ISCSI != nil {
                        if a.VolumeSource.ISCSI.ISCSIInterface == "" {
                                a.VolumeSource.ISCSI.ISCSIInterface = "default"
                        }
                }
                if a.VolumeSource.RBD != nil {
                        if a.VolumeSource.RBD.RBDPool == "" {
                                a.VolumeSource.RBD.RBDPool = "rbd"
                        }
                        if a.VolumeSource.RBD.RadosUser == "" {
                                a.VolumeSource.RBD.RadosUser = "admin"
                        }
                        if a.VolumeSource.RBD.Keyring == "" {
                                a.VolumeSource.RBD.Keyring = "/etc/ceph/keyring"
                        }
                }
                if a.VolumeSource.DownwardAPI != nil {
                        corev1.SetDefaults_DownwardAPIVolumeSource(a.VolumeSource.DownwardAPI)
                        for j := range a.VolumeSource.DownwardAPI.Items {
                                b := &a.VolumeSource.DownwardAPI.Items[j]
                                if b.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.FieldRef)
                                }
                        }
                }
                if a.VolumeSource.ConfigMap != nil {
                        corev1.SetDefaults_ConfigMapVolumeSource(a.VolumeSource.ConfigMap)
                }
                if a.VolumeSource.AzureDisk != nil {
                        if a.VolumeSource.AzureDisk.CachingMode == nil {
                                ptrVar1 := v1.AzureDataDiskCachingMode(v1.AzureDataDiskCachingReadWrite)
                                a.VolumeSource.AzureDisk.CachingMode = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.FSType == nil {
                                var ptrVar1 string = "ext4"
                                a.VolumeSource.AzureDisk.FSType = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.ReadOnly == nil {
                                var ptrVar1 bool = false
                                a.VolumeSource.AzureDisk.ReadOnly = &ptrVar1
                        }
                        if a.VolumeSource.AzureDisk.Kind == nil {
                                ptrVar1 := v1.AzureDataDiskKind(v1.AzureSharedBlobDisk)
                                a.VolumeSource.AzureDisk.Kind = &ptrVar1
                        }
                }
                if a.VolumeSource.Projected != nil {
                        corev1.SetDefaults_ProjectedVolumeSource(a.VolumeSource.Projected)
                        for j := range a.VolumeSource.Projected.Sources {
                                b := &a.VolumeSource.Projected.Sources[j]
                                if b.DownwardAPI != nil {
                                        for k := range b.DownwardAPI.Items {
                                                c := &b.DownwardAPI.Items[k]
                                                if c.FieldRef != nil {
                                                        corev1.SetDefaults_ObjectFieldSelector(c.FieldRef)
                                                }
                                        }
                                }
                                if b.ServiceAccountToken != nil {
                                        corev1.SetDefaults_ServiceAccountTokenProjection(b.ServiceAccountToken)
                                }
                        }
                }
                if a.VolumeSource.ScaleIO != nil {
                        if a.VolumeSource.ScaleIO.StorageMode == "" {
                                a.VolumeSource.ScaleIO.StorageMode = "ThinProvisioned"
                        }
                        if a.VolumeSource.ScaleIO.FSType == "" {
                                a.VolumeSource.ScaleIO.FSType = "xfs"
                        }
                }
                if a.VolumeSource.Ephemeral != nil {
                        if a.VolumeSource.Ephemeral.VolumeClaimTemplate != nil {
                                corev1.SetDefaults_PersistentVolumeClaimSpec(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Limits)
                                corev1.SetDefaults_ResourceList(&a.VolumeSource.Ephemeral.VolumeClaimTemplate.Spec.Resources.Requests)
                        }
                }
        }
        for i := range in.Spec.Template.Spec.InitContainers {
                a := &in.Spec.Template.Spec.InitContainers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.Containers {
                a := &in.Spec.Template.Spec.Containers[i]
                corev1.SetDefaults_Container(a)
                for j := range a.Ports {
                        b := &a.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.Env {
                        b := &a.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.Resources.Requests)
                if a.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.LivenessProbe)
                        if a.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.ReadinessProbe)
                        if a.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.StartupProbe)
                        if a.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.Lifecycle != nil {
                        if a.Lifecycle.PostStart != nil {
                                if a.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.Lifecycle.PreStop != nil {
                                if a.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        for i := range in.Spec.Template.Spec.EphemeralContainers {
                a := &in.Spec.Template.Spec.EphemeralContainers[i]
                corev1.SetDefaults_EphemeralContainer(a)
                for j := range a.EphemeralContainerCommon.Ports {
                        b := &a.EphemeralContainerCommon.Ports[j]
                        if b.Protocol == "" {
                                b.Protocol = "TCP"
                        }
                }
                for j := range a.EphemeralContainerCommon.Env {
                        b := &a.EphemeralContainerCommon.Env[j]
                        if b.ValueFrom != nil {
                                if b.ValueFrom.FieldRef != nil {
                                        corev1.SetDefaults_ObjectFieldSelector(b.ValueFrom.FieldRef)
                                }
                                if b.ValueFrom.FileKeyRef != nil {
                                        if b.ValueFrom.FileKeyRef.Optional == nil {
                                                var ptrVar1 bool = false
                                                b.ValueFrom.FileKeyRef.Optional = &ptrVar1
                                        }
                                }
                        }
                }
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Limits)
                corev1.SetDefaults_ResourceList(&a.EphemeralContainerCommon.Resources.Requests)
                if a.EphemeralContainerCommon.LivenessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.LivenessProbe)
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.LivenessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.ReadinessProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.ReadinessProbe)
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.ReadinessProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.StartupProbe != nil {
                        corev1.SetDefaults_Probe(a.EphemeralContainerCommon.StartupProbe)
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet != nil {
                                corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.StartupProbe.ProbeHandler.HTTPGet)
                        }
                        if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC != nil {
                                if a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service == nil {
                                        var ptrVar1 string = ""
                                        a.EphemeralContainerCommon.StartupProbe.ProbeHandler.GRPC.Service = &ptrVar1
                                }
                        }
                }
                if a.EphemeralContainerCommon.Lifecycle != nil {
                        if a.EphemeralContainerCommon.Lifecycle.PostStart != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PostStart.HTTPGet)
                                }
                        }
                        if a.EphemeralContainerCommon.Lifecycle.PreStop != nil {
                                if a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet != nil {
                                        corev1.SetDefaults_HTTPGetAction(a.EphemeralContainerCommon.Lifecycle.PreStop.HTTPGet)
                                }
                        }
                }
        }
        corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Overhead)
        if in.Spec.Template.Spec.Resources != nil {
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Limits)
                corev1.SetDefaults_ResourceList(&in.Spec.Template.Spec.Resources.Requests)
        }
}

func SetObjectDefaults_ReplicaSetList(in *extensionsv1beta1.ReplicaSetList) {
        for i := range in.Items {
                a := &in.Items[i]
                SetObjectDefaults_ReplicaSet(a)
        }
}

/*
Copyright 2022 The Kubernetes Authors.

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.
*/

package fuzzer

import (
        "sigs.k8s.io/randfill"

        runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
        "k8s.io/kubernetes/pkg/apis/flowcontrol"
        "k8s.io/utils/ptr"
)

// Funcs returns the fuzzer functions for the flowcontrol api group.
var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
        return []interface{}{
                func(obj *flowcontrol.LimitedPriorityLevelConfiguration, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again

                        // NOTE: setting a zero value here will cause the roundtrip
                        // test (from internal to v1beta2, v1beta1) to fail
                        if obj.NominalConcurrencyShares == 0 {
                                obj.NominalConcurrencyShares = int32(1)
                        }
                        if obj.LendablePercent == nil {
                                obj.LendablePercent = ptr.To(int32(0))
                        }
                },
                func(obj *flowcontrol.ExemptPriorityLevelConfiguration, c randfill.Continue) {
                        c.FillNoCustom(obj) // fuzz self without calling this function again
                        if obj.NominalConcurrencyShares == nil {
                                obj.NominalConcurrencyShares = ptr.To(int32(0))
                        }
                        if obj.LendablePercent == nil {
                                obj.LendablePercent = ptr.To(int32(0))
                        }
                },
        }
}

/*
Copyright 2015 The Kubernetes Authors.

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.
*/

// Package install installs the experimental API group, making it available as
// an option to all of the API encoding/decoding machinery.
package install

import (
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/kubernetes/pkg/api/legacyscheme"
        "k8s.io/kubernetes/pkg/apis/flowcontrol"
        flowcontrolv1 "k8s.io/kubernetes/pkg/apis/flowcontrol/v1"
        flowcontrolv1beta1 "k8s.io/kubernetes/pkg/apis/flowcontrol/v1beta1"
        flowcontrolv1beta2 "k8s.io/kubernetes/pkg/apis/flowcontrol/v1beta2"
        flowcontrolv1beta3 "k8s.io/kubernetes/pkg/apis/flowcontrol/v1beta3"
)

func init() {
        Install(legacyscheme.Scheme)
}

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
        utilruntime.Must(flowcontrol.AddToScheme(scheme))
        utilruntime.Must(flowcontrolv1beta1.AddToScheme(scheme))
        utilruntime.Must(flowcontrolv1beta2.AddToScheme(scheme))
        utilruntime.Must(flowcontrolv1beta3.AddToScheme(scheme))
        utilruntime.Must(flowcontrolv1.AddToScheme(scheme))

        utilruntime.Must(scheme.SetVersionPriority(flowcontrolv1.SchemeGroupVersion, flowcontrolv1beta3.SchemeGroupVersion,
                flowcontrolv1beta2.SchemeGroupVersion, flowcontrolv1beta1.SchemeGroupVersion))
}

/*
Copyright 2016 The Kubernetes Authors.

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.
*/

package flowcontrol

import (
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the name of api group
const GroupName = "flowcontrol.apiserver.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

// Kind takes an unqualified kind and returns a Group qualified GroupKind
func Kind(kind string) schema.GroupKind {
        return SchemeGroupVersion.WithKind(kind).GroupKind()
}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        // SchemeBuilder installs the api group to a scheme
        SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
        // AddToScheme adds api to a scheme
        AddToScheme = SchemeBuilder.AddToScheme
)

// Adds the list of known types to the given scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
        scheme.AddKnownTypes(SchemeGroupVersion,
                &FlowSchema{},
                &FlowSchemaList{},
                &PriorityLevelConfiguration{},
                &PriorityLevelConfigurationList{},
        )
        return nil
}

/*
Copyright 2023 The Kubernetes Authors.

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.
*/

package v1

import (
        v1 "k8s.io/api/flowcontrol/v1"
        "k8s.io/utils/ptr"
)

// Default settings for flow-schema
const (
        FlowSchemaDefaultMatchingPrecedence int32 = 1000
)

// Default settings for priority-level-configuration
const (
        PriorityLevelConfigurationDefaultHandSize                 int32 = 8
        PriorityLevelConfigurationDefaultQueues                   int32 = 64
        PriorityLevelConfigurationDefaultQueueLengthLimit         int32 = 50
        PriorityLevelConfigurationDefaultNominalConcurrencyShares int32 = 30
)

// SetDefaults_FlowSchema sets default values for flow schema
func SetDefaults_FlowSchemaSpec(spec *v1.FlowSchemaSpec) {
        if spec.MatchingPrecedence == 0 {
                spec.MatchingPrecedence = FlowSchemaDefaultMatchingPrecedence
        }
}

func SetDefaults_ExemptPriorityLevelConfiguration(eplc *v1.ExemptPriorityLevelConfiguration) {
        if eplc.NominalConcurrencyShares == nil {
                eplc.NominalConcurrencyShares = new(int32)
                *eplc.NominalConcurrencyShares = 0
        }
        if eplc.LendablePercent == nil {
                eplc.LendablePercent = new(int32)
                *eplc.LendablePercent = 0
        }
}

func SetDefaults_LimitedPriorityLevelConfiguration(lplc *v1.LimitedPriorityLevelConfiguration) {
        if lplc.NominalConcurrencyShares == nil {
                lplc.NominalConcurrencyShares = ptr.To(PriorityLevelConfigurationDefaultNominalConcurrencyShares)
        }
        if lplc.LendablePercent == nil {
                lplc.LendablePercent = new(int32)
                *lplc.LendablePercent = 0
        }
}

// SetDefaults_FlowSchema sets default values for flow schema
func SetDefaults_QueuingConfiguration(cfg *v1.QueuingConfiguration) {
        if cfg.HandSize == 0 {
                cfg.HandSize = PriorityLevelConfigurationDefaultHandSize
        }
        if cfg.Queues == 0 {
                cfg.Queues = PriorityLevelConfigurationDefaultQueues
        }
        if cfg.QueueLengthLimit == 0 {
                cfg.QueueLengthLimit = PriorityLevelConfigurationDefaultQueueLengthLimit
        }
}

/*
Copyright 2023 The Kubernetes Authors.

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.
*/

package v1

import (
        flowcontrolv1 "k8s.io/api/flowcontrol/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "flowcontrol.apiserver.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
        return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
        localSchemeBuilder = &flowcontrolv1.SchemeBuilder
        // AddToScheme adds api to a scheme
        AddToScheme = localSchemeBuilder.AddToScheme
)

func init() {
        // We only register manually written functions here. The registration of the
        // generated functions takes place in the generated files. The separation
        // makes the code compile even when the generated files are missing.
        localSchemeBuilder.Register(RegisterDefaults)
}

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

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 conversion-gen. DO NOT EDIT.

package v1

import (
        unsafe "unsafe"

        flowcontrolv1 "k8s.io/api/flowcontrol/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        conversion "k8s.io/apimachinery/pkg/conversion"
        runtime "k8s.io/apimachinery/pkg/runtime"
        flowcontrol "k8s.io/kubernetes/pkg/apis/flowcontrol"
)

func init() {
        localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.ExemptPriorityLevelConfiguration)(nil), (*flowcontrol.ExemptPriorityLevelConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ExemptPriorityLevelConfiguration_To_flowcontrol_ExemptPriorityLevelConfiguration(a.(*flowcontrolv1.ExemptPriorityLevelConfiguration), b.(*flowcontrol.ExemptPriorityLevelConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.ExemptPriorityLevelConfiguration)(nil), (*flowcontrolv1.ExemptPriorityLevelConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_ExemptPriorityLevelConfiguration_To_v1_ExemptPriorityLevelConfiguration(a.(*flowcontrol.ExemptPriorityLevelConfiguration), b.(*flowcontrolv1.ExemptPriorityLevelConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.FlowDistinguisherMethod)(nil), (*flowcontrol.FlowDistinguisherMethod)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlowDistinguisherMethod_To_flowcontrol_FlowDistinguisherMethod(a.(*flowcontrolv1.FlowDistinguisherMethod), b.(*flowcontrol.FlowDistinguisherMethod), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.FlowDistinguisherMethod)(nil), (*flowcontrolv1.FlowDistinguisherMethod)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_FlowDistinguisherMethod_To_v1_FlowDistinguisherMethod(a.(*flowcontrol.FlowDistinguisherMethod), b.(*flowcontrolv1.FlowDistinguisherMethod), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.FlowSchema)(nil), (*flowcontrol.FlowSchema)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlowSchema_To_flowcontrol_FlowSchema(a.(*flowcontrolv1.FlowSchema), b.(*flowcontrol.FlowSchema), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.FlowSchema)(nil), (*flowcontrolv1.FlowSchema)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_FlowSchema_To_v1_FlowSchema(a.(*flowcontrol.FlowSchema), b.(*flowcontrolv1.FlowSchema), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.FlowSchemaCondition)(nil), (*flowcontrol.FlowSchemaCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlowSchemaCondition_To_flowcontrol_FlowSchemaCondition(a.(*flowcontrolv1.FlowSchemaCondition), b.(*flowcontrol.FlowSchemaCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.FlowSchemaCondition)(nil), (*flowcontrolv1.FlowSchemaCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_FlowSchemaCondition_To_v1_FlowSchemaCondition(a.(*flowcontrol.FlowSchemaCondition), b.(*flowcontrolv1.FlowSchemaCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.FlowSchemaList)(nil), (*flowcontrol.FlowSchemaList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlowSchemaList_To_flowcontrol_FlowSchemaList(a.(*flowcontrolv1.FlowSchemaList), b.(*flowcontrol.FlowSchemaList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.FlowSchemaList)(nil), (*flowcontrolv1.FlowSchemaList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_FlowSchemaList_To_v1_FlowSchemaList(a.(*flowcontrol.FlowSchemaList), b.(*flowcontrolv1.FlowSchemaList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.FlowSchemaSpec)(nil), (*flowcontrol.FlowSchemaSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlowSchemaSpec_To_flowcontrol_FlowSchemaSpec(a.(*flowcontrolv1.FlowSchemaSpec), b.(*flowcontrol.FlowSchemaSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.FlowSchemaSpec)(nil), (*flowcontrolv1.FlowSchemaSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_FlowSchemaSpec_To_v1_FlowSchemaSpec(a.(*flowcontrol.FlowSchemaSpec), b.(*flowcontrolv1.FlowSchemaSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.FlowSchemaStatus)(nil), (*flowcontrol.FlowSchemaStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_FlowSchemaStatus_To_flowcontrol_FlowSchemaStatus(a.(*flowcontrolv1.FlowSchemaStatus), b.(*flowcontrol.FlowSchemaStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.FlowSchemaStatus)(nil), (*flowcontrolv1.FlowSchemaStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_FlowSchemaStatus_To_v1_FlowSchemaStatus(a.(*flowcontrol.FlowSchemaStatus), b.(*flowcontrolv1.FlowSchemaStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.GroupSubject)(nil), (*flowcontrol.GroupSubject)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_GroupSubject_To_flowcontrol_GroupSubject(a.(*flowcontrolv1.GroupSubject), b.(*flowcontrol.GroupSubject), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.GroupSubject)(nil), (*flowcontrolv1.GroupSubject)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_GroupSubject_To_v1_GroupSubject(a.(*flowcontrol.GroupSubject), b.(*flowcontrolv1.GroupSubject), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.LimitResponse)(nil), (*flowcontrol.LimitResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LimitResponse_To_flowcontrol_LimitResponse(a.(*flowcontrolv1.LimitResponse), b.(*flowcontrol.LimitResponse), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.LimitResponse)(nil), (*flowcontrolv1.LimitResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_LimitResponse_To_v1_LimitResponse(a.(*flowcontrol.LimitResponse), b.(*flowcontrolv1.LimitResponse), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.LimitedPriorityLevelConfiguration)(nil), (*flowcontrol.LimitedPriorityLevelConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration(a.(*flowcontrolv1.LimitedPriorityLevelConfiguration), b.(*flowcontrol.LimitedPriorityLevelConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.LimitedPriorityLevelConfiguration)(nil), (*flowcontrolv1.LimitedPriorityLevelConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1_LimitedPriorityLevelConfiguration(a.(*flowcontrol.LimitedPriorityLevelConfiguration), b.(*flowcontrolv1.LimitedPriorityLevelConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.NonResourcePolicyRule)(nil), (*flowcontrol.NonResourcePolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_NonResourcePolicyRule_To_flowcontrol_NonResourcePolicyRule(a.(*flowcontrolv1.NonResourcePolicyRule), b.(*flowcontrol.NonResourcePolicyRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.NonResourcePolicyRule)(nil), (*flowcontrolv1.NonResourcePolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_NonResourcePolicyRule_To_v1_NonResourcePolicyRule(a.(*flowcontrol.NonResourcePolicyRule), b.(*flowcontrolv1.NonResourcePolicyRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.PolicyRulesWithSubjects)(nil), (*flowcontrol.PolicyRulesWithSubjects)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PolicyRulesWithSubjects_To_flowcontrol_PolicyRulesWithSubjects(a.(*flowcontrolv1.PolicyRulesWithSubjects), b.(*flowcontrol.PolicyRulesWithSubjects), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.PolicyRulesWithSubjects)(nil), (*flowcontrolv1.PolicyRulesWithSubjects)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_PolicyRulesWithSubjects_To_v1_PolicyRulesWithSubjects(a.(*flowcontrol.PolicyRulesWithSubjects), b.(*flowcontrolv1.PolicyRulesWithSubjects), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.PriorityLevelConfiguration)(nil), (*flowcontrol.PriorityLevelConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PriorityLevelConfiguration_To_flowcontrol_PriorityLevelConfiguration(a.(*flowcontrolv1.PriorityLevelConfiguration), b.(*flowcontrol.PriorityLevelConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.PriorityLevelConfiguration)(nil), (*flowcontrolv1.PriorityLevelConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_PriorityLevelConfiguration_To_v1_PriorityLevelConfiguration(a.(*flowcontrol.PriorityLevelConfiguration), b.(*flowcontrolv1.PriorityLevelConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.PriorityLevelConfigurationCondition)(nil), (*flowcontrol.PriorityLevelConfigurationCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PriorityLevelConfigurationCondition_To_flowcontrol_PriorityLevelConfigurationCondition(a.(*flowcontrolv1.PriorityLevelConfigurationCondition), b.(*flowcontrol.PriorityLevelConfigurationCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.PriorityLevelConfigurationCondition)(nil), (*flowcontrolv1.PriorityLevelConfigurationCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_PriorityLevelConfigurationCondition_To_v1_PriorityLevelConfigurationCondition(a.(*flowcontrol.PriorityLevelConfigurationCondition), b.(*flowcontrolv1.PriorityLevelConfigurationCondition), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.PriorityLevelConfigurationList)(nil), (*flowcontrol.PriorityLevelConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PriorityLevelConfigurationList_To_flowcontrol_PriorityLevelConfigurationList(a.(*flowcontrolv1.PriorityLevelConfigurationList), b.(*flowcontrol.PriorityLevelConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.PriorityLevelConfigurationList)(nil), (*flowcontrolv1.PriorityLevelConfigurationList)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_PriorityLevelConfigurationList_To_v1_PriorityLevelConfigurationList(a.(*flowcontrol.PriorityLevelConfigurationList), b.(*flowcontrolv1.PriorityLevelConfigurationList), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.PriorityLevelConfigurationReference)(nil), (*flowcontrol.PriorityLevelConfigurationReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PriorityLevelConfigurationReference_To_flowcontrol_PriorityLevelConfigurationReference(a.(*flowcontrolv1.PriorityLevelConfigurationReference), b.(*flowcontrol.PriorityLevelConfigurationReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.PriorityLevelConfigurationReference)(nil), (*flowcontrolv1.PriorityLevelConfigurationReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_PriorityLevelConfigurationReference_To_v1_PriorityLevelConfigurationReference(a.(*flowcontrol.PriorityLevelConfigurationReference), b.(*flowcontrolv1.PriorityLevelConfigurationReference), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.PriorityLevelConfigurationSpec)(nil), (*flowcontrol.PriorityLevelConfigurationSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PriorityLevelConfigurationSpec_To_flowcontrol_PriorityLevelConfigurationSpec(a.(*flowcontrolv1.PriorityLevelConfigurationSpec), b.(*flowcontrol.PriorityLevelConfigurationSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.PriorityLevelConfigurationSpec)(nil), (*flowcontrolv1.PriorityLevelConfigurationSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_PriorityLevelConfigurationSpec_To_v1_PriorityLevelConfigurationSpec(a.(*flowcontrol.PriorityLevelConfigurationSpec), b.(*flowcontrolv1.PriorityLevelConfigurationSpec), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.PriorityLevelConfigurationStatus)(nil), (*flowcontrol.PriorityLevelConfigurationStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_PriorityLevelConfigurationStatus_To_flowcontrol_PriorityLevelConfigurationStatus(a.(*flowcontrolv1.PriorityLevelConfigurationStatus), b.(*flowcontrol.PriorityLevelConfigurationStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.PriorityLevelConfigurationStatus)(nil), (*flowcontrolv1.PriorityLevelConfigurationStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_PriorityLevelConfigurationStatus_To_v1_PriorityLevelConfigurationStatus(a.(*flowcontrol.PriorityLevelConfigurationStatus), b.(*flowcontrolv1.PriorityLevelConfigurationStatus), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.QueuingConfiguration)(nil), (*flowcontrol.QueuingConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_QueuingConfiguration_To_flowcontrol_QueuingConfiguration(a.(*flowcontrolv1.QueuingConfiguration), b.(*flowcontrol.QueuingConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.QueuingConfiguration)(nil), (*flowcontrolv1.QueuingConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_QueuingConfiguration_To_v1_QueuingConfiguration(a.(*flowcontrol.QueuingConfiguration), b.(*flowcontrolv1.QueuingConfiguration), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.ResourcePolicyRule)(nil), (*flowcontrol.ResourcePolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ResourcePolicyRule_To_flowcontrol_ResourcePolicyRule(a.(*flowcontrolv1.ResourcePolicyRule), b.(*flowcontrol.ResourcePolicyRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.ResourcePolicyRule)(nil), (*flowcontrolv1.ResourcePolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_ResourcePolicyRule_To_v1_ResourcePolicyRule(a.(*flowcontrol.ResourcePolicyRule), b.(*flowcontrolv1.ResourcePolicyRule), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.ServiceAccountSubject)(nil), (*flowcontrol.ServiceAccountSubject)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_ServiceAccountSubject_To_flowcontrol_ServiceAccountSubject(a.(*flowcontrolv1.ServiceAccountSubject), b.(*flowcontrol.ServiceAccountSubject), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.ServiceAccountSubject)(nil), (*flowcontrolv1.ServiceAccountSubject)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_ServiceAccountSubject_To_v1_ServiceAccountSubject(a.(*flowcontrol.ServiceAccountSubject), b.(*flowcontrolv1.ServiceAccountSubject), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.Subject)(nil), (*flowcontrol.Subject)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_Subject_To_flowcontrol_Subject(a.(*flowcontrolv1.Subject), b.(*flowcontrol.Subject), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.Subject)(nil), (*flowcontrolv1.Subject)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_Subject_To_v1_Subject(a.(*flowcontrol.Subject), b.(*flowcontrolv1.Subject), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrolv1.UserSubject)(nil), (*flowcontrol.UserSubject)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_v1_UserSubject_To_flowcontrol_UserSubject(a.(*flowcontrolv1.UserSubject), b.(*flowcontrol.UserSubject), scope)
        }); err != nil {
                return err
        }
        if err := s.AddGeneratedConversionFunc((*flowcontrol.UserSubject)(nil), (*flowcontrolv1.UserSubject)(nil), func(a, b interface{}, scope conversion.Scope) error {
                return Convert_flowcontrol_UserSubject_To_v1_UserSubject(a.(*flowcontrol.UserSubject), b.(*flowcontrolv1.UserSubject), scope)
        }); err != nil {
                return err
        }
        return nil
}

func autoConvert_v1_ExemptPriorityLevelConfiguration_To_flowcontrol_ExemptPriorityLevelConfiguration(in *flowcontrolv1.ExemptPriorityLevelConfiguration, out *flowcontrol.ExemptPriorityLevelConfiguration, s conversion.Scope) error {
        out.NominalConcurrencyShares = (*int32)(unsafe.Pointer(in.NominalConcurrencyShares))
        out.LendablePercent = (*int32)(unsafe.Pointer(in.LendablePercent))
        return nil
}

// Convert_v1_ExemptPriorityLevelConfiguration_To_flowcontrol_ExemptPriorityLevelConfiguration is an autogenerated conversion function.
func Convert_v1_ExemptPriorityLevelConfiguration_To_flowcontrol_ExemptPriorityLevelConfiguration(in *flowcontrolv1.ExemptPriorityLevelConfiguration, out *flowcontrol.ExemptPriorityLevelConfiguration, s conversion.Scope) error {
        return autoConvert_v1_ExemptPriorityLevelConfiguration_To_flowcontrol_ExemptPriorityLevelConfiguration(in, out, s)
}

func autoConvert_flowcontrol_ExemptPriorityLevelConfiguration_To_v1_ExemptPriorityLevelConfiguration(in *flowcontrol.ExemptPriorityLevelConfiguration, out *flowcontrolv1.ExemptPriorityLevelConfiguration, s conversion.Scope) error {
        out.NominalConcurrencyShares = (*int32)(unsafe.Pointer(in.NominalConcurrencyShares))
        out.LendablePercent = (*int32)(unsafe.Pointer(in.LendablePercent))
        return nil
}

// Convert_flowcontrol_ExemptPriorityLevelConfiguration_To_v1_ExemptPriorityLevelConfiguration is an autogenerated conversion function.
func Convert_flowcontrol_ExemptPriorityLevelConfiguration_To_v1_ExemptPriorityLevelConfiguration(in *flowcontrol.ExemptPriorityLevelConfiguration, out *flowcontrolv1.ExemptPriorityLevelConfiguration, s conversion.Scope) error {
        return autoConvert_flowcontrol_ExemptPriorityLevelConfiguration_To_v1_ExemptPriorityLevelConfiguration(in, out, s)
}

func autoConvert_v1_FlowDistinguisherMethod_To_flowcontrol_FlowDistinguisherMethod(in *flowcontrolv1.FlowDistinguisherMethod, out *flowcontrol.FlowDistinguisherMethod, s conversion.Scope) error {
        out.Type = flowcontrol.FlowDistinguisherMethodType(in.Type)
        return nil
}

// Convert_v1_FlowDistinguisherMethod_To_flowcontrol_FlowDistinguisherMethod is an autogenerated conversion function.
func Convert_v1_FlowDistinguisherMethod_To_flowcontrol_FlowDistinguisherMethod(in *flowcontrolv1.FlowDistinguisherMethod, out *flowcontrol.FlowDistinguisherMethod, s conversion.Scope) error {
        return autoConvert_v1_FlowDistinguisherMethod_To_flowcontrol_FlowDistinguisherMethod(in, out, s)
}

func autoConvert_flowcontrol_FlowDistinguisherMethod_To_v1_FlowDistinguisherMethod(in *flowcontrol.FlowDistinguisherMethod, out *flowcontrolv1.FlowDistinguisherMethod, s conversion.Scope) error {
        out.Type = flowcontrolv1.FlowDistinguisherMethodType(in.Type)
        return nil
}

// Convert_flowcontrol_FlowDistinguisherMethod_To_v1_FlowDistinguisherMethod is an autogenerated conversion function.
func Convert_flowcontrol_FlowDistinguisherMethod_To_v1_FlowDistinguisherMethod(in *flowcontrol.FlowDistinguisherMethod, out *flowcontrolv1.FlowDistinguisherMethod, s conversion.Scope) error {
        return autoConvert_flowcontrol_FlowDistinguisherMethod_To_v1_FlowDistinguisherMethod(in, out, s)
}

func autoConvert_v1_FlowSchema_To_flowcontrol_FlowSchema(in *flowcontrolv1.FlowSchema, out *flowcontrol.FlowSchema, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_FlowSchemaSpec_To_flowcontrol_FlowSchemaSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_FlowSchemaStatus_To_flowcontrol_FlowSchemaStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_FlowSchema_To_flowcontrol_FlowSchema is an autogenerated conversion function.
func Convert_v1_FlowSchema_To_flowcontrol_FlowSchema(in *flowcontrolv1.FlowSchema, out *flowcontrol.FlowSchema, s conversion.Scope) error {
        return autoConvert_v1_FlowSchema_To_flowcontrol_FlowSchema(in, out, s)
}

func autoConvert_flowcontrol_FlowSchema_To_v1_FlowSchema(in *flowcontrol.FlowSchema, out *flowcontrolv1.FlowSchema, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_flowcontrol_FlowSchemaSpec_To_v1_FlowSchemaSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_flowcontrol_FlowSchemaStatus_To_v1_FlowSchemaStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_flowcontrol_FlowSchema_To_v1_FlowSchema is an autogenerated conversion function.
func Convert_flowcontrol_FlowSchema_To_v1_FlowSchema(in *flowcontrol.FlowSchema, out *flowcontrolv1.FlowSchema, s conversion.Scope) error {
        return autoConvert_flowcontrol_FlowSchema_To_v1_FlowSchema(in, out, s)
}

func autoConvert_v1_FlowSchemaCondition_To_flowcontrol_FlowSchemaCondition(in *flowcontrolv1.FlowSchemaCondition, out *flowcontrol.FlowSchemaCondition, s conversion.Scope) error {
        out.Type = flowcontrol.FlowSchemaConditionType(in.Type)
        out.Status = flowcontrol.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_v1_FlowSchemaCondition_To_flowcontrol_FlowSchemaCondition is an autogenerated conversion function.
func Convert_v1_FlowSchemaCondition_To_flowcontrol_FlowSchemaCondition(in *flowcontrolv1.FlowSchemaCondition, out *flowcontrol.FlowSchemaCondition, s conversion.Scope) error {
        return autoConvert_v1_FlowSchemaCondition_To_flowcontrol_FlowSchemaCondition(in, out, s)
}

func autoConvert_flowcontrol_FlowSchemaCondition_To_v1_FlowSchemaCondition(in *flowcontrol.FlowSchemaCondition, out *flowcontrolv1.FlowSchemaCondition, s conversion.Scope) error {
        out.Type = flowcontrolv1.FlowSchemaConditionType(in.Type)
        out.Status = flowcontrolv1.ConditionStatus(in.Status)
        out.LastTransitionTime = in.LastTransitionTime
        out.Reason = in.Reason
        out.Message = in.Message
        return nil
}

// Convert_flowcontrol_FlowSchemaCondition_To_v1_FlowSchemaCondition is an autogenerated conversion function.
func Convert_flowcontrol_FlowSchemaCondition_To_v1_FlowSchemaCondition(in *flowcontrol.FlowSchemaCondition, out *flowcontrolv1.FlowSchemaCondition, s conversion.Scope) error {
        return autoConvert_flowcontrol_FlowSchemaCondition_To_v1_FlowSchemaCondition(in, out, s)
}

func autoConvert_v1_FlowSchemaList_To_flowcontrol_FlowSchemaList(in *flowcontrolv1.FlowSchemaList, out *flowcontrol.FlowSchemaList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]flowcontrol.FlowSchema)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_v1_FlowSchemaList_To_flowcontrol_FlowSchemaList is an autogenerated conversion function.
func Convert_v1_FlowSchemaList_To_flowcontrol_FlowSchemaList(in *flowcontrolv1.FlowSchemaList, out *flowcontrol.FlowSchemaList, s conversion.Scope) error {
        return autoConvert_v1_FlowSchemaList_To_flowcontrol_FlowSchemaList(in, out, s)
}

func autoConvert_flowcontrol_FlowSchemaList_To_v1_FlowSchemaList(in *flowcontrol.FlowSchemaList, out *flowcontrolv1.FlowSchemaList, s conversion.Scope) error {
        out.ListMeta = in.ListMeta
        out.Items = *(*[]flowcontrolv1.FlowSchema)(unsafe.Pointer(&in.Items))
        return nil
}

// Convert_flowcontrol_FlowSchemaList_To_v1_FlowSchemaList is an autogenerated conversion function.
func Convert_flowcontrol_FlowSchemaList_To_v1_FlowSchemaList(in *flowcontrol.FlowSchemaList, out *flowcontrolv1.FlowSchemaList, s conversion.Scope) error {
        return autoConvert_flowcontrol_FlowSchemaList_To_v1_FlowSchemaList(in, out, s)
}

func autoConvert_v1_FlowSchemaSpec_To_flowcontrol_FlowSchemaSpec(in *flowcontrolv1.FlowSchemaSpec, out *flowcontrol.FlowSchemaSpec, s conversion.Scope) error {
        if err := Convert_v1_PriorityLevelConfigurationReference_To_flowcontrol_PriorityLevelConfigurationReference(&in.PriorityLevelConfiguration, &out.PriorityLevelConfiguration, s); err != nil {
                return err
        }
        out.MatchingPrecedence = in.MatchingPrecedence
        out.DistinguisherMethod = (*flowcontrol.FlowDistinguisherMethod)(unsafe.Pointer(in.DistinguisherMethod))
        out.Rules = *(*[]flowcontrol.PolicyRulesWithSubjects)(unsafe.Pointer(&in.Rules))
        return nil
}

// Convert_v1_FlowSchemaSpec_To_flowcontrol_FlowSchemaSpec is an autogenerated conversion function.
func Convert_v1_FlowSchemaSpec_To_flowcontrol_FlowSchemaSpec(in *flowcontrolv1.FlowSchemaSpec, out *flowcontrol.FlowSchemaSpec, s conversion.Scope) error {
        return autoConvert_v1_FlowSchemaSpec_To_flowcontrol_FlowSchemaSpec(in, out, s)
}

func autoConvert_flowcontrol_FlowSchemaSpec_To_v1_FlowSchemaSpec(in *flowcontrol.FlowSchemaSpec, out *flowcontrolv1.FlowSchemaSpec, s conversion.Scope) error {
        if err := Convert_flowcontrol_PriorityLevelConfigurationReference_To_v1_PriorityLevelConfigurationReference(&in.PriorityLevelConfiguration, &out.PriorityLevelConfiguration, s); err != nil {
                return err
        }
        out.MatchingPrecedence = in.MatchingPrecedence
        out.DistinguisherMethod = (*flowcontrolv1.FlowDistinguisherMethod)(unsafe.Pointer(in.DistinguisherMethod))
        out.Rules = *(*[]flowcontrolv1.PolicyRulesWithSubjects)(unsafe.Pointer(&in.Rules))
        return nil
}

// Convert_flowcontrol_FlowSchemaSpec_To_v1_FlowSchemaSpec is an autogenerated conversion function.
func Convert_flowcontrol_FlowSchemaSpec_To_v1_FlowSchemaSpec(in *flowcontrol.FlowSchemaSpec, out *flowcontrolv1.FlowSchemaSpec, s conversion.Scope) error {
        return autoConvert_flowcontrol_FlowSchemaSpec_To_v1_FlowSchemaSpec(in, out, s)
}

func autoConvert_v1_FlowSchemaStatus_To_flowcontrol_FlowSchemaStatus(in *flowcontrolv1.FlowSchemaStatus, out *flowcontrol.FlowSchemaStatus, s conversion.Scope) error {
        out.Conditions = *(*[]flowcontrol.FlowSchemaCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_v1_FlowSchemaStatus_To_flowcontrol_FlowSchemaStatus is an autogenerated conversion function.
func Convert_v1_FlowSchemaStatus_To_flowcontrol_FlowSchemaStatus(in *flowcontrolv1.FlowSchemaStatus, out *flowcontrol.FlowSchemaStatus, s conversion.Scope) error {
        return autoConvert_v1_FlowSchemaStatus_To_flowcontrol_FlowSchemaStatus(in, out, s)
}

func autoConvert_flowcontrol_FlowSchemaStatus_To_v1_FlowSchemaStatus(in *flowcontrol.FlowSchemaStatus, out *flowcontrolv1.FlowSchemaStatus, s conversion.Scope) error {
        out.Conditions = *(*[]flowcontrolv1.FlowSchemaCondition)(unsafe.Pointer(&in.Conditions))
        return nil
}

// Convert_flowcontrol_FlowSchemaStatus_To_v1_FlowSchemaStatus is an autogenerated conversion function.
func Convert_flowcontrol_FlowSchemaStatus_To_v1_FlowSchemaStatus(in *flowcontrol.FlowSchemaStatus, out *flowcontrolv1.FlowSchemaStatus, s conversion.Scope) error {
        return autoConvert_flowcontrol_FlowSchemaStatus_To_v1_FlowSchemaStatus(in, out, s)
}

func autoConvert_v1_GroupSubject_To_flowcontrol_GroupSubject(in *flowcontrolv1.GroupSubject, out *flowcontrol.GroupSubject, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_v1_GroupSubject_To_flowcontrol_GroupSubject is an autogenerated conversion function.
func Convert_v1_GroupSubject_To_flowcontrol_GroupSubject(in *flowcontrolv1.GroupSubject, out *flowcontrol.GroupSubject, s conversion.Scope) error {
        return autoConvert_v1_GroupSubject_To_flowcontrol_GroupSubject(in, out, s)
}

func autoConvert_flowcontrol_GroupSubject_To_v1_GroupSubject(in *flowcontrol.GroupSubject, out *flowcontrolv1.GroupSubject, s conversion.Scope) error {
        out.Name = in.Name
        return nil
}

// Convert_flowcontrol_GroupSubject_To_v1_GroupSubject is an autogenerated conversion function.
func Convert_flowcontrol_GroupSubject_To_v1_GroupSubject(in *flowcontrol.GroupSubject, out *flowcontrolv1.GroupSubject, s conversion.Scope) error {
        return autoConvert_flowcontrol_GroupSubject_To_v1_GroupSubject(in, out, s)
}

func autoConvert_v1_LimitResponse_To_flowcontrol_LimitResponse(in *flowcontrolv1.LimitResponse, out *flowcontrol.LimitResponse, s conversion.Scope) error {
        out.Type = flowcontrol.LimitResponseType(in.Type)
        out.Queuing = (*flowcontrol.QueuingConfiguration)(unsafe.Pointer(in.Queuing))
        return nil
}

// Convert_v1_LimitResponse_To_flowcontrol_LimitResponse is an autogenerated conversion function.
func Convert_v1_LimitResponse_To_flowcontrol_LimitResponse(in *flowcontrolv1.LimitResponse, out *flowcontrol.LimitResponse, s conversion.Scope) error {
        return autoConvert_v1_LimitResponse_To_flowcontrol_LimitResponse(in, out, s)
}

func autoConvert_flowcontrol_LimitResponse_To_v1_LimitResponse(in *flowcontrol.LimitResponse, out *flowcontrolv1.LimitResponse, s conversion.Scope) error {
        out.Type = flowcontrolv1.LimitResponseType(in.Type)
        out.Queuing = (*flowcontrolv1.QueuingConfiguration)(unsafe.Pointer(in.Queuing))
        return nil
}

// Convert_flowcontrol_LimitResponse_To_v1_LimitResponse is an autogenerated conversion function.
func Convert_flowcontrol_LimitResponse_To_v1_LimitResponse(in *flowcontrol.LimitResponse, out *flowcontrolv1.LimitResponse, s conversion.Scope) error {
        return autoConvert_flowcontrol_LimitResponse_To_v1_LimitResponse(in, out, s)
}

func autoConvert_v1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration(in *flowcontrolv1.LimitedPriorityLevelConfiguration, out *flowcontrol.LimitedPriorityLevelConfiguration, s conversion.Scope) error {
        if err := metav1.Convert_Pointer_int32_To_int32(&in.NominalConcurrencyShares, &out.NominalConcurrencyShares, s); err != nil {
                return err
        }
        if err := Convert_v1_LimitResponse_To_flowcontrol_LimitResponse(&in.LimitResponse, &out.LimitResponse, s); err != nil {
                return err
        }
        out.LendablePercent = (*int32)(unsafe.Pointer(in.LendablePercent))
        out.BorrowingLimitPercent = (*int32)(unsafe.Pointer(in.BorrowingLimitPercent))
        return nil
}

// Convert_v1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration is an autogenerated conversion function.
func Convert_v1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration(in *flowcontrolv1.LimitedPriorityLevelConfiguration, out *flowcontrol.LimitedPriorityLevelConfiguration, s conversion.Scope) error {
        return autoConvert_v1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration(in, out, s)
}

func autoConvert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1_LimitedPriorityLevelConfiguration(in *flowcontrol.LimitedPriorityLevelConfiguration, out *flowcontrolv1.LimitedPriorityLevelConfiguration, s conversion.Scope) error {
        if err := metav1.Convert_int32_To_Pointer_int32(&in.NominalConcurrencyShares, &out.NominalConcurrencyShares, s); err != nil {
                return err
        }
        if err := Convert_flowcontrol_LimitResponse_To_v1_LimitResponse(&in.LimitResponse, &out.LimitResponse, s); err != nil {
                return err
        }
        out.LendablePercent = (*int32)(unsafe.Pointer(in.LendablePercent))
        out.BorrowingLimitPercent = (*int32)(unsafe.Pointer(in.BorrowingLimitPercent))
        return nil
}

// Convert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1_LimitedPriorityLevelConfiguration is an autogenerated conversion function.
func Convert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1_LimitedPriorityLevelConfiguration(in *flowcontrol.LimitedPriorityLevelConfiguration, out *flowcontrolv1.LimitedPriorityLevelConfiguration, s conversion.Scope) error {
        return autoConvert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1_LimitedPriorityLevelConfiguration(in, out, s)
}

func autoConvert_v1_NonResourcePolicyRule_To_flowcontrol_NonResourcePolicyRule(in *flowcontrolv1.NonResourcePolicyRule, out *flowcontrol.NonResourcePolicyRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs))
        return nil
}

// Convert_v1_NonResourcePolicyRule_To_flowcontrol_NonResourcePolicyRule is an autogenerated conversion function.
func Convert_v1_NonResourcePolicyRule_To_flowcontrol_NonResourcePolicyRule(in *flowcontrolv1.NonResourcePolicyRule, out *flowcontrol.NonResourcePolicyRule, s conversion.Scope) error {
        return autoConvert_v1_NonResourcePolicyRule_To_flowcontrol_NonResourcePolicyRule(in, out, s)
}

func autoConvert_flowcontrol_NonResourcePolicyRule_To_v1_NonResourcePolicyRule(in *flowcontrol.NonResourcePolicyRule, out *flowcontrolv1.NonResourcePolicyRule, s conversion.Scope) error {
        out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
        out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs))
        return nil
}

// Convert_flowcontrol_NonResourcePolicyRule_To_v1_NonResourcePolicyRule is an autogenerated conversion function.
func Convert_flowcontrol_NonResourcePolicyRule_To_v1_NonResourcePolicyRule(in *flowcontrol.NonResourcePolicyRule, out *flowcontrolv1.NonResourcePolicyRule, s conversion.Scope) error {
        return autoConvert_flowcontrol_NonResourcePolicyRule_To_v1_NonResourcePolicyRule(in, out, s)
}

func autoConvert_v1_PolicyRulesWithSubjects_To_flowcontrol_PolicyRulesWithSubjects(in *flowcontrolv1.PolicyRulesWithSubjects, out *flowcontrol.PolicyRulesWithSubjects, s conversion.Scope) error {
        out.Subjects = *(*[]flowcontrol.Subject)(unsafe.Pointer(&in.Subjects))
        out.ResourceRules = *(*[]flowcontrol.ResourcePolicyRule)(unsafe.Pointer(&in.ResourceRules))
        out.NonResourceRules = *(*[]flowcontrol.NonResourcePolicyRule)(unsafe.Pointer(&in.NonResourceRules))
        return nil
}

// Convert_v1_PolicyRulesWithSubjects_To_flowcontrol_PolicyRulesWithSubjects is an autogenerated conversion function.
func Convert_v1_PolicyRulesWithSubjects_To_flowcontrol_PolicyRulesWithSubjects(in *flowcontrolv1.PolicyRulesWithSubjects, out *flowcontrol.PolicyRulesWithSubjects, s conversion.Scope) error {
        return autoConvert_v1_PolicyRulesWithSubjects_To_flowcontrol_PolicyRulesWithSubjects(in, out, s)
}

func autoConvert_flowcontrol_PolicyRulesWithSubjects_To_v1_PolicyRulesWithSubjects(in *flowcontrol.PolicyRulesWithSubjects, out *flowcontrolv1.PolicyRulesWithSubjects, s conversion.Scope) error {
        out.Subjects = *(*[]flowcontrolv1.Subject)(unsafe.Pointer(&in.Subjects))
        out.ResourceRules = *(*[]flowcontrolv1.ResourcePolicyRule)(unsafe.Pointer(&in.ResourceRules))
        out.NonResourceRules = *(*[]flowcontrolv1.NonResourcePolicyRule)(unsafe.Pointer(&in.NonResourceRules))
        return nil
}

// Convert_flowcontrol_PolicyRulesWithSubjects_To_v1_PolicyRulesWithSubjects is an autogenerated conversion function.
func Convert_flowcontrol_PolicyRulesWithSubjects_To_v1_PolicyRulesWithSubjects(in *flowcontrol.PolicyRulesWithSubjects, out *flowcontrolv1.PolicyRulesWithSubjects, s conversion.Scope) error {
        return autoConvert_flowcontrol_PolicyRulesWithSubjects_To_v1_PolicyRulesWithSubjects(in, out, s)
}

func autoConvert_v1_PriorityLevelConfiguration_To_flowcontrol_PriorityLevelConfiguration(in *flowcontrolv1.PriorityLevelConfiguration, out *flowcontrol.PriorityLevelConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_v1_PriorityLevelConfigurationSpec_To_flowcontrol_PriorityLevelConfigurationSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_v1_PriorityLevelConfigurationStatus_To_flowcontrol_PriorityLevelConfigurationStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_v1_PriorityLevelConfiguration_To_flowcontrol_PriorityLevelConfiguration is an autogenerated conversion function.
func Convert_v1_PriorityLevelConfiguration_To_flowcontrol_PriorityLevelConfiguration(in *flowcontrolv1.PriorityLevelConfiguration, out *flowcontrol.PriorityLevelConfiguration, s conversion.Scope) error {
        return autoConvert_v1_PriorityLevelConfiguration_To_flowcontrol_PriorityLevelConfiguration(in, out, s)
}

func autoConvert_flowcontrol_PriorityLevelConfiguration_To_v1_PriorityLevelConfiguration(in *flowcontrol.PriorityLevelConfiguration, out *flowcontrolv1.PriorityLevelConfiguration, s conversion.Scope) error {
        out.ObjectMeta = in.ObjectMeta
        if err := Convert_flowcontrol_PriorityLevelConfigurationSpec_To_v1_PriorityLevelConfigurationSpec(&in.Spec, &out.Spec, s); err != nil {
                return err
        }
        if err := Convert_flowcontrol_PriorityLevelConfigurationStatus_To_v1_PriorityLevelConfigurationStatus(&in.Status, &out.Status, s); err != nil {
                return err
        }
        return nil
}

// Convert_flowcontrol_PriorityLevelConfiguration_To_v1_PriorityLevelConfiguration is an autogenerated conversion function.
func Convert_flowcontrol_PriorityLevelConfiguration_To_v1_PriorityLevelConfiguration(in *flowcontrol.PriorityLevelConfiguration, out *flowcontrolv1.PriorityLevelConfiguration, s conversion.Scope) error {
        return autoConvert_flowcontrol_PriorityLevelConfiguration_To_v1_PriorityLevelConfiguration(in, out, s)
}

func autoConvert_v1_PriorityLevelConfigurationCondition_To_flowcontrol_PriorityLevelConfigurationCondition(in *flowcontrolv1.PriorityLevelConfigurationCondition, out *flowcontrol.PriorityLevelConfigurationCondition, s conversion.Scope) error {
        out.Type = flowcontrol.PriorityLevelConfigurationConditionType(in.Type)
        out.Status = flowcontrol.ConditionStatus(in.St