apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.17.3
  name: gatewayapis.operator.tigera.io
spec:
  group: operator.tigera.io
  names:
    kind: GatewayAPI
    listKind: GatewayAPIList
    plural: gatewayapis
    singular: gatewayapi
  scope: Cluster
  versions:
    - name: v1
      schema:
        openAPIV3Schema:
          properties:
            apiVersion:
              description: |-
                APIVersion defines the versioned schema of this representation of an object.
                Servers should convert recognized schemas to the latest internal value, and
                may reject unrecognized values.
                More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
              type: string
            kind:
              description: |-
                Kind is a string value representing the REST resource this object represents.
                Servers may infer this from the endpoint the client submits requests to.
                Cannot be updated.
                In CamelCase.
                More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
              type: string
            metadata:
              type: object
            spec:
              description:
                GatewayAPISpec has fields that can be used to customize our
                GatewayAPI support.
              properties:
                crdManagement:
                  description: |-
                    Configure how to manage and update Gateway API CRDs.  The default behaviour - which is
                    used when this field is not set, or is set to "PreferExisting" - is that the Tigera
                    operator will create the Gateway API CRDs if they do not already exist, but will not
                    overwrite any existing Gateway API CRDs.  This setting may be preferable if the customer
                    is using other implementations of the Gateway API concurrently with the Gateway API
                    support in Calico Enterprise.  It is then the customer's responsibility to ensure that
                    CRDs are installed that meet the needs of all the Gateway API implementations in their
                    cluster.
                    Alternatively, if this field is set to "Reconcile", the Tigera operator will keep the
                    cluster's Gateway API CRDs aligned with those that it would install on a cluster that
                    does not yet have any version of those CRDs.
                  enum:
                    - Reconcile
                    - PreferExisting
                  type: string
                gatewayCertgenJob:
                  description: Allow optional customization of the gateway certgen job.
                  properties:
                    metadata:
                      description:
                        Metadata contains the standard Kubernetes labels
                        and annotations fields.
                      properties:
                        annotations:
                          additionalProperties:
                            type: string
                          description: |-
                            Annotations is a map of arbitrary non-identifying metadata. Each of these
                            key/value pairs are added to the object's annotations provided the key does not
                            already exist in the object's annotations.
                          type: object
                        labels:
                          additionalProperties:
                            type: string
                          description: |-
                            Labels is a map of string keys and values that may match replicaset and
                            service selectors. Each of these key/value pairs are added to the
                            object's labels provided the key does not already exist in the object's labels.
                          type: object
                      type: object
                    spec:
                      description: |-
                        GatewayCertgenJobSpec allows customization of the gateway certgen job spec.
                        For customization of the job template see GatewayCertgenJobPodTemplate.
                      properties:
                        template:
                          description: |-
                            GatewayCertgenJobPodTemplate allows customization of the gateway certgen job's pod template.
                            If GatewayCertgenJob.Spec.Template.Metadata is non-nil, non-clashing labels and
                            annotations from that metadata are added into the job's pod template.
                            For customization of the pod template spec see GatewayCertgenJobPodSpec.
                          properties:
                            metadata:
                              description:
                                Metadata contains the standard Kubernetes
                                labels and annotations fields.
                              properties:
                                annotations:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    Annotations is a map of arbitrary non-identifying metadata. Each of these
                                    key/value pairs are added to the object's annotations provided the key does not
                                    already exist in the object's annotations.
                                  type: object
                                labels:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    Labels is a map of string keys and values that may match replicaset and
                                    service selectors. Each of these key/value pairs are added to the
                                    object's labels provided the key does not already exist in the object's labels.
                                  type: object
                              type: object
                            spec:
                              description: |-
                                GatewayCertgenJobPodSpec allows customization of the gateway certgen job's pod spec.
                                If GatewayCertgenJob.Spec.Template.Spec.Affinity is non-nil, it sets the affinity field of the
                                job's pod template.
                                If GatewayCertgenJob.Spec.Template.Spec.NodeSelector is non-nil, it sets a node selector for
                                where job pods may be scheduled.
                                If GatewayCertgenJob.Spec.Template.Spec.Tolerations is non-nil, it sets the tolerations field of
                                the job's pod template.
                                For customization of job container resources see GatewayCertgenJobContainer.
                              properties:
                                affinity:
                                  description:
                                    Affinity is a group of affinity scheduling
                                    rules.
                                  properties:
                                    nodeAffinity:
                                      description:
                                        Describes node affinity scheduling
                                        rules for the pod.
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node matches the corresponding matchExpressions; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description: |-
                                              An empty preferred scheduling term matches all objects with implicit weight 0
                                              (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                                            properties:
                                              preference:
                                                description:
                                                  A node selector term, associated
                                                  with the corresponding weight.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's labels.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchFields:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's fields.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              weight:
                                                description:
                                                  Weight associated with
                                                  matching the corresponding nodeSelectorTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - preference
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to an update), the system
                                            may or may not try to eventually evict the pod from its node.
                                          properties:
                                            nodeSelectorTerms:
                                              description:
                                                Required. A list of node
                                                selector terms. The terms are ORed.
                                              items:
                                                description: |-
                                                  A null or empty node selector term matches no objects. The requirements of
                                                  them are ANDed.
                                                  The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's labels.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchFields:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's fields.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              type: array
                                              x-kubernetes-list-type: atomic
                                          required:
                                            - nodeSelectorTerms
                                          type: object
                                          x-kubernetes-map-type: atomic
                                      type: object
                                    podAffinity:
                                      description:
                                        Describes pod affinity scheduling
                                        rules (e.g. co-locate this pod in the same node,
                                        zone, etc. as some other pod(s)).
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description:
                                              The weights of all of the matched
                                              WeightedPodAffinityTerm fields are added
                                              per-node to find the most preferred node(s)
                                            properties:
                                              podAffinityTerm:
                                                description:
                                                  Required. A pod affinity
                                                  term, associated with the corresponding
                                                  weight.
                                                properties:
                                                  labelSelector:
                                                    description: |-
                                                      A label query over a set of resources, in this case pods.
                                                      If it's null, this PodAffinityTerm matches with no Pods.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  matchLabelKeys:
                                                    description: |-
                                                      MatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                      Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  mismatchLabelKeys:
                                                    description: |-
                                                      MismatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                      Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  namespaceSelector:
                                                    description: |-
                                                      A label query over the set of namespaces that the term applies to.
                                                      The term is applied to the union of the namespaces selected by this field
                                                      and the ones listed in the namespaces field.
                                                      null selector and null or empty namespaces list means "this pod's namespace".
                                                      An empty selector ({}) matches all namespaces.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  namespaces:
                                                    description: |-
                                                      namespaces specifies a static list of namespace names that the term applies to.
                                                      The term is applied to the union of the namespaces listed in this field
                                                      and the ones selected by namespaceSelector.
                                                      null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  topologyKey:
                                                    description: |-
                                                      This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                      the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                      whose value of the label with key topologyKey matches that of any node on which any of the
                                                      selected pods is running.
                                                      Empty topologyKey is not allowed.
                                                    type: string
                                                required:
                                                  - topologyKey
                                                type: object
                                              weight:
                                                description: |-
                                                  weight associated with matching the corresponding podAffinityTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - podAffinityTerm
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to a pod label update), the
                                            system may or may not try to eventually evict the pod from its node.
                                            When there are multiple elements, the lists of nodes corresponding to each
                                            podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                          items:
                                            description: |-
                                              Defines a set of pods (namely those matching the labelSelector
                                              relative to the given namespace(s)) that this pod should be
                                              co-located (affinity) or not co-located (anti-affinity) with,
                                              where co-located is defined as running on a node whose value of
                                              the label with key <topologyKey> matches that of any node on which
                                              a pod of the set of pods is running
                                            properties:
                                              labelSelector:
                                                description: |-
                                                  A label query over a set of resources, in this case pods.
                                                  If it's null, this PodAffinityTerm matches with no Pods.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              matchLabelKeys:
                                                description: |-
                                                  MatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                  Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              mismatchLabelKeys:
                                                description: |-
                                                  MismatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                  Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              namespaceSelector:
                                                description: |-
                                                  A label query over the set of namespaces that the term applies to.
                                                  The term is applied to the union of the namespaces selected by this field
                                                  and the ones listed in the namespaces field.
                                                  null selector and null or empty namespaces list means "this pod's namespace".
                                                  An empty selector ({}) matches all namespaces.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              namespaces:
                                                description: |-
                                                  namespaces specifies a static list of namespace names that the term applies to.
                                                  The term is applied to the union of the namespaces listed in this field
                                                  and the ones selected by namespaceSelector.
                                                  null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              topologyKey:
                                                description: |-
                                                  This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                  the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                  whose value of the label with key topologyKey matches that of any node on which any of the
                                                  selected pods is running.
                                                  Empty topologyKey is not allowed.
                                                type: string
                                            required:
                                              - topologyKey
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                      type: object
                                    podAntiAffinity:
                                      description:
                                        Describes pod anti-affinity scheduling
                                        rules (e.g. avoid putting this pod in the same
                                        node, zone, etc. as some other pod(s)).
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the anti-affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling anti-affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description:
                                              The weights of all of the matched
                                              WeightedPodAffinityTerm fields are added
                                              per-node to find the most preferred node(s)
                                            properties:
                                              podAffinityTerm:
                                                description:
                                                  Required. A pod affinity
                                                  term, associated with the corresponding
                                                  weight.
                                                properties:
                                                  labelSelector:
                                                    description: |-
                                                      A label query over a set of resources, in this case pods.
                                                      If it's null, this PodAffinityTerm matches with no Pods.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  matchLabelKeys:
                                                    description: |-
                                                      MatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                      Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  mismatchLabelKeys:
                                                    description: |-
                                                      MismatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                      Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  namespaceSelector:
                                                    description: |-
                                                      A label query over the set of namespaces that the term applies to.
                                                      The term is applied to the union of the namespaces selected by this field
                                                      and the ones listed in the namespaces field.
                                                      null selector and null or empty namespaces list means "this pod's namespace".
                                                      An empty selector ({}) matches all namespaces.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  namespaces:
                                                    description: |-
                                                      namespaces specifies a static list of namespace names that the term applies to.
                                                      The term is applied to the union of the namespaces listed in this field
                                                      and the ones selected by namespaceSelector.
                                                      null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  topologyKey:
                                                    description: |-
                                                      This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                      the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                      whose value of the label with key topologyKey matches that of any node on which any of the
                                                      selected pods is running.
                                                      Empty topologyKey is not allowed.
                                                    type: string
                                                required:
                                                  - topologyKey
                                                type: object
                                              weight:
                                                description: |-
                                                  weight associated with matching the corresponding podAffinityTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - podAffinityTerm
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the anti-affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the anti-affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to a pod label update), the
                                            system may or may not try to eventually evict the pod from its node.
                                            When there are multiple elements, the lists of nodes corresponding to each
                                            podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                          items:
                                            description: |-
                                              Defines a set of pods (namely those matching the labelSelector
                                              relative to the given namespace(s)) that this pod should be
                                              co-located (affinity) or not co-located (anti-affinity) with,
                                              where co-located is defined as running on a node whose value of
                                              the label with key <topologyKey> matches that of any node on which
                                              a pod of the set of pods is running
                                            properties:
                                              labelSelector:
                                                description: |-
                                                  A label query over a set of resources, in this case pods.
                                                  If it's null, this PodAffinityTerm matches with no Pods.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              matchLabelKeys:
                                                description: |-
                                                  MatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                  Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              mismatchLabelKeys:
                                                description: |-
                                                  MismatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                  Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              namespaceSelector:
                                                description: |-
                                                  A label query over the set of namespaces that the term applies to.
                                                  The term is applied to the union of the namespaces selected by this field
                                                  and the ones listed in the namespaces field.
                                                  null selector and null or empty namespaces list means "this pod's namespace".
                                                  An empty selector ({}) matches all namespaces.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              namespaces:
                                                description: |-
                                                  namespaces specifies a static list of namespace names that the term applies to.
                                                  The term is applied to the union of the namespaces listed in this field
                                                  and the ones selected by namespaceSelector.
                                                  null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              topologyKey:
                                                description: |-
                                                  This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                  the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                  whose value of the label with key topologyKey matches that of any node on which any of the
                                                  selected pods is running.
                                                  Empty topologyKey is not allowed.
                                                type: string
                                            required:
                                              - topologyKey
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                      type: object
                                  type: object
                                containers:
                                  items:
                                    description: |-
                                      GatewayCertgenJobContainer allows customization of the gateway certgen job's resource
                                      requirements.
                                      If GatewayCertgenJob.Spec.Template.Spec.Containers["envoy-gateway-certgen"].Resources is non-nil,
                                      it overrides the ResourceRequirements of the job's "envoy-gateway-certgen" container.
                                    properties:
                                      name:
                                        enum:
                                          - envoy-gateway-certgen
                                        type: string
                                      resources:
                                        description:
                                          ResourceRequirements describes
                                          the compute resource requirements.
                                        properties:
                                          claims:
                                            description: |-
                                              Claims lists the names of resources, defined in spec.resourceClaims,
                                              that are used by this container.
                                              This is an alpha field and requires enabling the
                                              DynamicResourceAllocation feature gate.
                                              This field is immutable. It can only be set for containers.
                                            items:
                                              description:
                                                ResourceClaim references
                                                one entry in PodSpec.ResourceClaims.
                                              properties:
                                                name:
                                                  description: |-
                                                    Name must match the name of one entry in pod.spec.resourceClaims of
                                                    the Pod where this field is used. It makes that resource available
                                                    inside a container.
                                                  type: string
                                                request:
                                                  description: |-
                                                    Request is the name chosen for a request in the referenced claim.
                                                    If empty, everything from the claim is made available, otherwise
                                                    only the result of this request.
                                                  type: string
                                              required:
                                                - name
                                              type: object
                                            type: array
                                            x-kubernetes-list-map-keys:
                                              - name
                                            x-kubernetes-list-type: map
                                          limits:
                                            additionalProperties:
                                              anyOf:
                                                - type: integer
                                                - type: string
                                              pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                              x-kubernetes-int-or-string: true
                                            description: |-
                                              Limits describes the maximum amount of compute resources allowed.
                                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                            type: object
                                          requests:
                                            additionalProperties:
                                              anyOf:
                                                - type: integer
                                                - type: string
                                              pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                              x-kubernetes-int-or-string: true
                                            description: |-
                                              Requests describes the minimum amount of compute resources required.
                                              If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                                              otherwise to an implementation-defined value. Requests cannot exceed Limits.
                                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                            type: object
                                        type: object
                                    required:
                                      - name
                                    type: object
                                  type: array
                                nodeSelector:
                                  additionalProperties:
                                    type: string
                                  type: object
                                tolerations:
                                  items:
                                    description: |-
                                      The pod this Toleration is attached to tolerates any taint that matches
                                      the triple <key,value,effect> using the matching operator <operator>.
                                    properties:
                                      effect:
                                        description: |-
                                          Effect indicates the taint effect to match. Empty means match all taint effects.
                                          When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
                                        type: string
                                      key:
                                        description: |-
                                          Key is the taint key that the toleration applies to. Empty means match all taint keys.
                                          If the key is empty, operator must be Exists; this combination means to match all values and all keys.
                                        type: string
                                      operator:
                                        description: |-
                                          Operator represents a key's relationship to the value.
                                          Valid operators are Exists and Equal. Defaults to Equal.
                                          Exists is equivalent to wildcard for value, so that a pod can
                                          tolerate all taints of a particular category.
                                        type: string
                                      tolerationSeconds:
                                        description: |-
                                          TolerationSeconds represents the period of time the toleration (which must be
                                          of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
                                          it is not set, which means tolerate the taint forever (do not evict). Zero and
                                          negative values will be treated as 0 (evict immediately) by the system.
                                        format: int64
                                        type: integer
                                      value:
                                        description: |-
                                          Value is the taint value the toleration matches to.
                                          If the operator is Exists, the value should be empty, otherwise just a regular string.
                                        type: string
                                    type: object
                                  type: array
                              type: object
                          type: object
                      type: object
                  type: object
                gatewayControllerDeployment:
                  description:
                    Allow optional customization of the gateway controller
                    deployment.
                  properties:
                    metadata:
                      description:
                        Metadata contains the standard Kubernetes labels
                        and annotations fields.
                      properties:
                        annotations:
                          additionalProperties:
                            type: string
                          description: |-
                            Annotations is a map of arbitrary non-identifying metadata. Each of these
                            key/value pairs are added to the object's annotations provided the key does not
                            already exist in the object's annotations.
                          type: object
                        labels:
                          additionalProperties:
                            type: string
                          description: |-
                            Labels is a map of string keys and values that may match replicaset and
                            service selectors. Each of these key/value pairs are added to the
                            object's labels provided the key does not already exist in the object's labels.
                          type: object
                      type: object
                    spec:
                      description: |-
                        GatewayControllerDeploymentSpec allows customization of the gateway controller deployment spec.
                        If GatewayControllerDeployment.Spec.MinReadySeconds is non-nil, it sets the minReadySeconds field
                        for the deployment.
                        For customization of the pod template see GatewayControllerDeploymentPodTemplate.
                      properties:
                        minReadySeconds:
                          format: int32
                          maximum: 2147483647
                          minimum: 0
                          type: integer
                        template:
                          description: |-
                            GatewayControllerDeploymentPodTemplate allows customization of the gateway controller deployment
                            pod template.
                            If GatewayControllerDeployment.Spec.Template.Metadata is non-nil, non-clashing labels and
                            annotations from that metadata are added into the deployment's pod template.
                            For customization of the pod template spec see GatewayControllerDeploymentPodSpec.
                          properties:
                            metadata:
                              description:
                                Metadata contains the standard Kubernetes
                                labels and annotations fields.
                              properties:
                                annotations:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    Annotations is a map of arbitrary non-identifying metadata. Each of these
                                    key/value pairs are added to the object's annotations provided the key does not
                                    already exist in the object's annotations.
                                  type: object
                                labels:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    Labels is a map of string keys and values that may match replicaset and
                                    service selectors. Each of these key/value pairs are added to the
                                    object's labels provided the key does not already exist in the object's labels.
                                  type: object
                              type: object
                            spec:
                              description: |-
                                GatewayControllerDeploymentPodSpec allows customization of the gateway controller deployment pod
                                spec.
                                If GatewayControllerDeployment.Spec.Template.Spec.Affinity is non-nil, it sets the affinity field
                                of the deployment's pod template.
                                If GatewayControllerDeployment.Spec.Template.Spec.NodeSelector is non-nil, it sets a node
                                selector for where controller pods may be scheduled.
                                If GatewayControllerDeployment.Spec.Template.Spec.Tolerations is non-nil, it sets the tolerations
                                field of the deployment's pod template.
                                For customization of container resources see GatewayControllerDeploymentContainer.
                              properties:
                                affinity:
                                  description:
                                    Affinity is a group of affinity scheduling
                                    rules.
                                  properties:
                                    nodeAffinity:
                                      description:
                                        Describes node affinity scheduling
                                        rules for the pod.
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node matches the corresponding matchExpressions; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description: |-
                                              An empty preferred scheduling term matches all objects with implicit weight 0
                                              (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                                            properties:
                                              preference:
                                                description:
                                                  A node selector term, associated
                                                  with the corresponding weight.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's labels.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchFields:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's fields.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              weight:
                                                description:
                                                  Weight associated with
                                                  matching the corresponding nodeSelectorTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - preference
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to an update), the system
                                            may or may not try to eventually evict the pod from its node.
                                          properties:
                                            nodeSelectorTerms:
                                              description:
                                                Required. A list of node
                                                selector terms. The terms are ORed.
                                              items:
                                                description: |-
                                                  A null or empty node selector term matches no objects. The requirements of
                                                  them are ANDed.
                                                  The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's labels.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchFields:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's fields.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              type: array
                                              x-kubernetes-list-type: atomic
                                          required:
                                            - nodeSelectorTerms
                                          type: object
                                          x-kubernetes-map-type: atomic
                                      type: object
                                    podAffinity:
                                      description:
                                        Describes pod affinity scheduling
                                        rules (e.g. co-locate this pod in the same node,
                                        zone, etc. as some other pod(s)).
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description:
                                              The weights of all of the matched
                                              WeightedPodAffinityTerm fields are added
                                              per-node to find the most preferred node(s)
                                            properties:
                                              podAffinityTerm:
                                                description:
                                                  Required. A pod affinity
                                                  term, associated with the corresponding
                                                  weight.
                                                properties:
                                                  labelSelector:
                                                    description: |-
                                                      A label query over a set of resources, in this case pods.
                                                      If it's null, this PodAffinityTerm matches with no Pods.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  matchLabelKeys:
                                                    description: |-
                                                      MatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                      Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  mismatchLabelKeys:
                                                    description: |-
                                                      MismatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                      Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  namespaceSelector:
                                                    description: |-
                                                      A label query over the set of namespaces that the term applies to.
                                                      The term is applied to the union of the namespaces selected by this field
                                                      and the ones listed in the namespaces field.
                                                      null selector and null or empty namespaces list means "this pod's namespace".
                                                      An empty selector ({}) matches all namespaces.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  namespaces:
                                                    description: |-
                                                      namespaces specifies a static list of namespace names that the term applies to.
                                                      The term is applied to the union of the namespaces listed in this field
                                                      and the ones selected by namespaceSelector.
                                                      null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  topologyKey:
                                                    description: |-
                                                      This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                      the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                      whose value of the label with key topologyKey matches that of any node on which any of the
                                                      selected pods is running.
                                                      Empty topologyKey is not allowed.
                                                    type: string
                                                required:
                                                  - topologyKey
                                                type: object
                                              weight:
                                                description: |-
                                                  weight associated with matching the corresponding podAffinityTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - podAffinityTerm
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to a pod label update), the
                                            system may or may not try to eventually evict the pod from its node.
                                            When there are multiple elements, the lists of nodes corresponding to each
                                            podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                          items:
                                            description: |-
                                              Defines a set of pods (namely those matching the labelSelector
                                              relative to the given namespace(s)) that this pod should be
                                              co-located (affinity) or not co-located (anti-affinity) with,
                                              where co-located is defined as running on a node whose value of
                                              the label with key <topologyKey> matches that of any node on which
                                              a pod of the set of pods is running
                                            properties:
                                              labelSelector:
                                                description: |-
                                                  A label query over a set of resources, in this case pods.
                                                  If it's null, this PodAffinityTerm matches with no Pods.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              matchLabelKeys:
                                                description: |-
                                                  MatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                  Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              mismatchLabelKeys:
                                                description: |-
                                                  MismatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                  Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              namespaceSelector:
                                                description: |-
                                                  A label query over the set of namespaces that the term applies to.
                                                  The term is applied to the union of the namespaces selected by this field
                                                  and the ones listed in the namespaces field.
                                                  null selector and null or empty namespaces list means "this pod's namespace".
                                                  An empty selector ({}) matches all namespaces.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              namespaces:
                                                description: |-
                                                  namespaces specifies a static list of namespace names that the term applies to.
                                                  The term is applied to the union of the namespaces listed in this field
                                                  and the ones selected by namespaceSelector.
                                                  null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              topologyKey:
                                                description: |-
                                                  This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                  the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                  whose value of the label with key topologyKey matches that of any node on which any of the
                                                  selected pods is running.
                                                  Empty topologyKey is not allowed.
                                                type: string
                                            required:
                                              - topologyKey
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                      type: object
                                    podAntiAffinity:
                                      description:
                                        Describes pod anti-affinity scheduling
                                        rules (e.g. avoid putting this pod in the same
                                        node, zone, etc. as some other pod(s)).
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the anti-affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling anti-affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description:
                                              The weights of all of the matched
                                              WeightedPodAffinityTerm fields are added
                                              per-node to find the most preferred node(s)
                                            properties:
                                              podAffinityTerm:
                                                description:
                                                  Required. A pod affinity
                                                  term, associated with the corresponding
                                                  weight.
                                                properties:
                                                  labelSelector:
                                                    description: |-
                                                      A label query over a set of resources, in this case pods.
                                                      If it's null, this PodAffinityTerm matches with no Pods.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  matchLabelKeys:
                                                    description: |-
                                                      MatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                      Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  mismatchLabelKeys:
                                                    description: |-
                                                      MismatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                      Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  namespaceSelector:
                                                    description: |-
                                                      A label query over the set of namespaces that the term applies to.
                                                      The term is applied to the union of the namespaces selected by this field
                                                      and the ones listed in the namespaces field.
                                                      null selector and null or empty namespaces list means "this pod's namespace".
                                                      An empty selector ({}) matches all namespaces.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  namespaces:
                                                    description: |-
                                                      namespaces specifies a static list of namespace names that the term applies to.
                                                      The term is applied to the union of the namespaces listed in this field
                                                      and the ones selected by namespaceSelector.
                                                      null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  topologyKey:
                                                    description: |-
                                                      This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                      the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                      whose value of the label with key topologyKey matches that of any node on which any of the
                                                      selected pods is running.
                                                      Empty topologyKey is not allowed.
                                                    type: string
                                                required:
                                                  - topologyKey
                                                type: object
                                              weight:
                                                description: |-
                                                  weight associated with matching the corresponding podAffinityTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - podAffinityTerm
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the anti-affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the anti-affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to a pod label update), the
                                            system may or may not try to eventually evict the pod from its node.
                                            When there are multiple elements, the lists of nodes corresponding to each
                                            podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                          items:
                                            description: |-
                                              Defines a set of pods (namely those matching the labelSelector
                                              relative to the given namespace(s)) that this pod should be
                                              co-located (affinity) or not co-located (anti-affinity) with,
                                              where co-located is defined as running on a node whose value of
                                              the label with key <topologyKey> matches that of any node on which
                                              a pod of the set of pods is running
                                            properties:
                                              labelSelector:
                                                description: |-
                                                  A label query over a set of resources, in this case pods.
                                                  If it's null, this PodAffinityTerm matches with no Pods.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              matchLabelKeys:
                                                description: |-
                                                  MatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                  Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              mismatchLabelKeys:
                                                description: |-
                                                  MismatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                  Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              namespaceSelector:
                                                description: |-
                                                  A label query over the set of namespaces that the term applies to.
                                                  The term is applied to the union of the namespaces selected by this field
                                                  and the ones listed in the namespaces field.
                                                  null selector and null or empty namespaces list means "this pod's namespace".
                                                  An empty selector ({}) matches all namespaces.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              namespaces:
                                                description: |-
                                                  namespaces specifies a static list of namespace names that the term applies to.
                                                  The term is applied to the union of the namespaces listed in this field
                                                  and the ones selected by namespaceSelector.
                                                  null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              topologyKey:
                                                description: |-
                                                  This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                  the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                  whose value of the label with key topologyKey matches that of any node on which any of the
                                                  selected pods is running.
                                                  Empty topologyKey is not allowed.
                                                type: string
                                            required:
                                              - topologyKey
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                      type: object
                                  type: object
                                containers:
                                  items:
                                    description: |-
                                      GatewayControllerDeploymentContainer allows customization of the gateway controller's resource
                                      requirements.
                                      If GatewayControllerDeployment.Spec.Template.Spec.Containers["envoy-gateway"].Resources is
                                      non-nil, it overrides the ResourceRequirements of the controller's "envoy-gateway" container.
                                    properties:
                                      name:
                                        enum:
                                          - envoy-gateway
                                        type: string
                                      resources:
                                        description:
                                          ResourceRequirements describes
                                          the compute resource requirements.
                                        properties:
                                          claims:
                                            description: |-
                                              Claims lists the names of resources, defined in spec.resourceClaims,
                                              that are used by this container.
                                              This is an alpha field and requires enabling the
                                              DynamicResourceAllocation feature gate.
                                              This field is immutable. It can only be set for containers.
                                            items:
                                              description:
                                                ResourceClaim references
                                                one entry in PodSpec.ResourceClaims.
                                              properties:
                                                name:
                                                  description: |-
                                                    Name must match the name of one entry in pod.spec.resourceClaims of
                                                    the Pod where this field is used. It makes that resource available
                                                    inside a container.
                                                  type: string
                                                request:
                                                  description: |-
                                                    Request is the name chosen for a request in the referenced claim.
                                                    If empty, everything from the claim is made available, otherwise
                                                    only the result of this request.
                                                  type: string
                                              required:
                                                - name
                                              type: object
                                            type: array
                                            x-kubernetes-list-map-keys:
                                              - name
                                            x-kubernetes-list-type: map
                                          limits:
                                            additionalProperties:
                                              anyOf:
                                                - type: integer
                                                - type: string
                                              pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                              x-kubernetes-int-or-string: true
                                            description: |-
                                              Limits describes the maximum amount of compute resources allowed.
                                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                            type: object
                                          requests:
                                            additionalProperties:
                                              anyOf:
                                                - type: integer
                                                - type: string
                                              pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                              x-kubernetes-int-or-string: true
                                            description: |-
                                              Requests describes the minimum amount of compute resources required.
                                              If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                                              otherwise to an implementation-defined value. Requests cannot exceed Limits.
                                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                            type: object
                                        type: object
                                    required:
                                      - name
                                    type: object
                                  type: array
                                nodeSelector:
                                  additionalProperties:
                                    type: string
                                  type: object
                                tolerations:
                                  items:
                                    description: |-
                                      The pod this Toleration is attached to tolerates any taint that matches
                                      the triple <key,value,effect> using the matching operator <operator>.
                                    properties:
                                      effect:
                                        description: |-
                                          Effect indicates the taint effect to match. Empty means match all taint effects.
                                          When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
                                        type: string
                                      key:
                                        description: |-
                                          Key is the taint key that the toleration applies to. Empty means match all taint keys.
                                          If the key is empty, operator must be Exists; this combination means to match all values and all keys.
                                        type: string
                                      operator:
                                        description: |-
                                          Operator represents a key's relationship to the value.
                                          Valid operators are Exists and Equal. Defaults to Equal.
                                          Exists is equivalent to wildcard for value, so that a pod can
                                          tolerate all taints of a particular category.
                                        type: string
                                      tolerationSeconds:
                                        description: |-
                                          TolerationSeconds represents the period of time the toleration (which must be
                                          of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
                                          it is not set, which means tolerate the taint forever (do not evict). Zero and
                                          negative values will be treated as 0 (evict immediately) by the system.
                                        format: int64
                                        type: integer
                                      value:
                                        description: |-
                                          Value is the taint value the toleration matches to.
                                          If the operator is Exists, the value should be empty, otherwise just a regular string.
                                        type: string
                                    type: object
                                  type: array
                              type: object
                          type: object
                      type: object
                  type: object
                gatewayDeployment:
                  description: Allow optional customization of gateway deployments.
                  properties:
                    spec:
                      description: |-
                        GatewayDeploymentSpec allows customization of the spec of gateway deployments.
                        For customization of the pod template see GatewayDeploymentPodTemplate.
                        For customization of the deployment strategy see GatewayDeploymentStrategy.
                      properties:
                        strategy:
                          description:
                            The deployment strategy to use to replace existing
                            pods with new ones.
                          properties:
                            rollingUpdate:
                              description:
                                Spec to control the desired behavior of rolling
                                update.
                              properties:
                                maxSurge:
                                  anyOf:
                                    - type: integer
                                    - type: string
                                  description: |-
                                    The maximum number of pods that can be scheduled above the desired number of
                                    pods.
                                    Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
                                    This can not be 0 if MaxUnavailable is 0.
                                    Absolute number is calculated from percentage by rounding up.
                                    Defaults to 25%.
                                    Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when
                                    the rolling update starts, such that the total number of old and new pods do not exceed
                                    130% of desired pods. Once old pods have been killed,
                                    new ReplicaSet can be scaled up further, ensuring that total number of pods running
                                    at any time during the update is at most 130% of desired pods.
                                  x-kubernetes-int-or-string: true
                                maxUnavailable:
                                  anyOf:
                                    - type: integer
                                    - type: string
                                  description: |-
                                    The maximum number of pods that can be unavailable during the update.
                                    Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
                                    Absolute number is calculated from percentage by rounding down.
                                    This can not be 0 if MaxSurge is 0.
                                    Defaults to 25%.
                                    Example: when this is set to 30%, the old ReplicaSet can be scaled down to 70% of desired pods
                                    immediately when the rolling update starts. Once new pods are ready, old ReplicaSet
                                    can be scaled down further, followed by scaling up the new ReplicaSet, ensuring
                                    that the total number of pods available at all times during the update is at
                                    least 70% of desired pods.
                                  x-kubernetes-int-or-string: true
                              type: object
                          type: object
                        template:
                          description: |-
                            GatewayDeploymentPodTemplate allows customization of the pod template of gateway deployments.
                            If GatewayDeployment.Spec.Template.Metadata is non-nil, non-clashing labels and annotations from
                            that metadata are added into each deployment's pod template.
                            For customization of the pod template spec see GatewayDeploymentPodSpec.
                          properties:
                            metadata:
                              description:
                                Metadata contains the standard Kubernetes
                                labels and annotations fields.
                              properties:
                                annotations:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    Annotations is a map of arbitrary non-identifying metadata. Each of these
                                    key/value pairs are added to the object's annotations provided the key does not
                                    already exist in the object's annotations.
                                  type: object
                                labels:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    Labels is a map of string keys and values that may match replicaset and
                                    service selectors. Each of these key/value pairs are added to the
                                    object's labels provided the key does not already exist in the object's labels.
                                  type: object
                              type: object
                            spec:
                              description: |-
                                GatewayDeploymentPodSpec allows customization of the pod spec of gateway deployments.
                                If GatewayDeployment.Spec.Template.Spec.Affinity is non-nil, it sets the affinity field of each
                                deployment's pod template.
                                If GatewayDeployment.Spec.Template.Spec.NodeSelector is non-nil, it sets a node selector for
                                where gateway pods may be scheduled.
                                If GatewayDeployment.Spec.Template.Spec.Tolerations is non-nil, it sets the tolerations field of
                                each deployment's pod template.
                                If GatewayDeployment.Spec.Template.Spec.TopologySpreadConstraints is non-nil, it sets the
                                topology spread constraints of each deployment's pod template.
                                For customization of container resources see GatewayControllerDeploymentContainer.
                              properties:
                                affinity:
                                  description:
                                    Affinity is a group of affinity scheduling
                                    rules.
                                  properties:
                                    nodeAffinity:
                                      description:
                                        Describes node affinity scheduling
                                        rules for the pod.
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node matches the corresponding matchExpressions; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description: |-
                                              An empty preferred scheduling term matches all objects with implicit weight 0
                                              (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                                            properties:
                                              preference:
                                                description:
                                                  A node selector term, associated
                                                  with the corresponding weight.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's labels.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchFields:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's fields.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              weight:
                                                description:
                                                  Weight associated with
                                                  matching the corresponding nodeSelectorTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - preference
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to an update), the system
                                            may or may not try to eventually evict the pod from its node.
                                          properties:
                                            nodeSelectorTerms:
                                              description:
                                                Required. A list of node
                                                selector terms. The terms are ORed.
                                              items:
                                                description: |-
                                                  A null or empty node selector term matches no objects. The requirements of
                                                  them are ANDed.
                                                  The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's labels.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchFields:
                                                    description:
                                                      A list of node selector
                                                      requirements by node's fields.
                                                    items:
                                                      description: |-
                                                        A node selector requirement is a selector that contains values, a key, and an operator
                                                        that relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            The label key
                                                            that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            Represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            An array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. If the operator is Gt or Lt, the values
                                                            array must have a single element, which will be interpreted as an integer.
                                                            This array is replaced during a strategic merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              type: array
                                              x-kubernetes-list-type: atomic
                                          required:
                                            - nodeSelectorTerms
                                          type: object
                                          x-kubernetes-map-type: atomic
                                      type: object
                                    podAffinity:
                                      description:
                                        Describes pod affinity scheduling
                                        rules (e.g. co-locate this pod in the same node,
                                        zone, etc. as some other pod(s)).
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description:
                                              The weights of all of the matched
                                              WeightedPodAffinityTerm fields are added
                                              per-node to find the most preferred node(s)
                                            properties:
                                              podAffinityTerm:
                                                description:
                                                  Required. A pod affinity
                                                  term, associated with the corresponding
                                                  weight.
                                                properties:
                                                  labelSelector:
                                                    description: |-
                                                      A label query over a set of resources, in this case pods.
                                                      If it's null, this PodAffinityTerm matches with no Pods.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  matchLabelKeys:
                                                    description: |-
                                                      MatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                      Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  mismatchLabelKeys:
                                                    description: |-
                                                      MismatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                      Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  namespaceSelector:
                                                    description: |-
                                                      A label query over the set of namespaces that the term applies to.
                                                      The term is applied to the union of the namespaces selected by this field
                                                      and the ones listed in the namespaces field.
                                                      null selector and null or empty namespaces list means "this pod's namespace".
                                                      An empty selector ({}) matches all namespaces.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  namespaces:
                                                    description: |-
                                                      namespaces specifies a static list of namespace names that the term applies to.
                                                      The term is applied to the union of the namespaces listed in this field
                                                      and the ones selected by namespaceSelector.
                                                      null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  topologyKey:
                                                    description: |-
                                                      This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                      the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                      whose value of the label with key topologyKey matches that of any node on which any of the
                                                      selected pods is running.
                                                      Empty topologyKey is not allowed.
                                                    type: string
                                                required:
                                                  - topologyKey
                                                type: object
                                              weight:
                                                description: |-
                                                  weight associated with matching the corresponding podAffinityTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - podAffinityTerm
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to a pod label update), the
                                            system may or may not try to eventually evict the pod from its node.
                                            When there are multiple elements, the lists of nodes corresponding to each
                                            podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                          items:
                                            description: |-
                                              Defines a set of pods (namely those matching the labelSelector
                                              relative to the given namespace(s)) that this pod should be
                                              co-located (affinity) or not co-located (anti-affinity) with,
                                              where co-located is defined as running on a node whose value of
                                              the label with key <topologyKey> matches that of any node on which
                                              a pod of the set of pods is running
                                            properties:
                                              labelSelector:
                                                description: |-
                                                  A label query over a set of resources, in this case pods.
                                                  If it's null, this PodAffinityTerm matches with no Pods.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              matchLabelKeys:
                                                description: |-
                                                  MatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                  Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              mismatchLabelKeys:
                                                description: |-
                                                  MismatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                  Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              namespaceSelector:
                                                description: |-
                                                  A label query over the set of namespaces that the term applies to.
                                                  The term is applied to the union of the namespaces selected by this field
                                                  and the ones listed in the namespaces field.
                                                  null selector and null or empty namespaces list means "this pod's namespace".
                                                  An empty selector ({}) matches all namespaces.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              namespaces:
                                                description: |-
                                                  namespaces specifies a static list of namespace names that the term applies to.
                                                  The term is applied to the union of the namespaces listed in this field
                                                  and the ones selected by namespaceSelector.
                                                  null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              topologyKey:
                                                description: |-
                                                  This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                  the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                  whose value of the label with key topologyKey matches that of any node on which any of the
                                                  selected pods is running.
                                                  Empty topologyKey is not allowed.
                                                type: string
                                            required:
                                              - topologyKey
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                      type: object
                                    podAntiAffinity:
                                      description:
                                        Describes pod anti-affinity scheduling
                                        rules (e.g. avoid putting this pod in the same
                                        node, zone, etc. as some other pod(s)).
                                      properties:
                                        preferredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            The scheduler will prefer to schedule pods to nodes that satisfy
                                            the anti-affinity expressions specified by this field, but it may choose
                                            a node that violates one or more of the expressions. The node that is
                                            most preferred is the one with the greatest sum of weights, i.e.
                                            for each node that meets all of the scheduling requirements (resource
                                            request, requiredDuringScheduling anti-affinity expressions, etc.),
                                            compute a sum by iterating through the elements of this field and adding
                                            "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                            node(s) with the highest sum are the most preferred.
                                          items:
                                            description:
                                              The weights of all of the matched
                                              WeightedPodAffinityTerm fields are added
                                              per-node to find the most preferred node(s)
                                            properties:
                                              podAffinityTerm:
                                                description:
                                                  Required. A pod affinity
                                                  term, associated with the corresponding
                                                  weight.
                                                properties:
                                                  labelSelector:
                                                    description: |-
                                                      A label query over a set of resources, in this case pods.
                                                      If it's null, this PodAffinityTerm matches with no Pods.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  matchLabelKeys:
                                                    description: |-
                                                      MatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                      Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  mismatchLabelKeys:
                                                    description: |-
                                                      MismatchLabelKeys is a set of pod label keys to select which pods will
                                                      be taken into consideration. The keys are used to lookup values from the
                                                      incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                      to select the group of existing pods which pods will be taken into consideration
                                                      for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                      pod labels will be ignored. The default value is empty.
                                                      The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                      Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                      This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  namespaceSelector:
                                                    description: |-
                                                      A label query over the set of namespaces that the term applies to.
                                                      The term is applied to the union of the namespaces selected by this field
                                                      and the ones listed in the namespaces field.
                                                      null selector and null or empty namespaces list means "this pod's namespace".
                                                      An empty selector ({}) matches all namespaces.
                                                    properties:
                                                      matchExpressions:
                                                        description:
                                                          matchExpressions
                                                          is a list of label selector
                                                          requirements. The requirements
                                                          are ANDed.
                                                        items:
                                                          description: |-
                                                            A label selector requirement is a selector that contains values, a key, and an operator that
                                                            relates the key and values.
                                                          properties:
                                                            key:
                                                              description:
                                                                key is the
                                                                label key that the selector
                                                                applies to.
                                                              type: string
                                                            operator:
                                                              description: |-
                                                                operator represents a key's relationship to a set of values.
                                                                Valid operators are In, NotIn, Exists and DoesNotExist.
                                                              type: string
                                                            values:
                                                              description: |-
                                                                values is an array of string values. If the operator is In or NotIn,
                                                                the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                the values array must be empty. This array is replaced during a strategic
                                                                merge patch.
                                                              items:
                                                                type: string
                                                              type: array
                                                              x-kubernetes-list-type: atomic
                                                          required:
                                                            - key
                                                            - operator
                                                          type: object
                                                        type: array
                                                        x-kubernetes-list-type: atomic
                                                      matchLabels:
                                                        additionalProperties:
                                                          type: string
                                                        description: |-
                                                          matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                          map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                          operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                        type: object
                                                    type: object
                                                    x-kubernetes-map-type: atomic
                                                  namespaces:
                                                    description: |-
                                                      namespaces specifies a static list of namespace names that the term applies to.
                                                      The term is applied to the union of the namespaces listed in this field
                                                      and the ones selected by namespaceSelector.
                                                      null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                    items:
                                                      type: string
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  topologyKey:
                                                    description: |-
                                                      This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                      the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                      whose value of the label with key topologyKey matches that of any node on which any of the
                                                      selected pods is running.
                                                      Empty topologyKey is not allowed.
                                                    type: string
                                                required:
                                                  - topologyKey
                                                type: object
                                              weight:
                                                description: |-
                                                  weight associated with matching the corresponding podAffinityTerm,
                                                  in the range 1-100.
                                                format: int32
                                                type: integer
                                            required:
                                              - podAffinityTerm
                                              - weight
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        requiredDuringSchedulingIgnoredDuringExecution:
                                          description: |-
                                            If the anti-affinity requirements specified by this field are not met at
                                            scheduling time, the pod will not be scheduled onto the node.
                                            If the anti-affinity requirements specified by this field cease to be met
                                            at some point during pod execution (e.g. due to a pod label update), the
                                            system may or may not try to eventually evict the pod from its node.
                                            When there are multiple elements, the lists of nodes corresponding to each
                                            podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                          items:
                                            description: |-
                                              Defines a set of pods (namely those matching the labelSelector
                                              relative to the given namespace(s)) that this pod should be
                                              co-located (affinity) or not co-located (anti-affinity) with,
                                              where co-located is defined as running on a node whose value of
                                              the label with key <topologyKey> matches that of any node on which
                                              a pod of the set of pods is running
                                            properties:
                                              labelSelector:
                                                description: |-
                                                  A label query over a set of resources, in this case pods.
                                                  If it's null, this PodAffinityTerm matches with no Pods.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              matchLabelKeys:
                                                description: |-
                                                  MatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                                  Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              mismatchLabelKeys:
                                                description: |-
                                                  MismatchLabelKeys is a set of pod label keys to select which pods will
                                                  be taken into consideration. The keys are used to lookup values from the
                                                  incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                                  to select the group of existing pods which pods will be taken into consideration
                                                  for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                  pod labels will be ignored. The default value is empty.
                                                  The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                                  Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                                  This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              namespaceSelector:
                                                description: |-
                                                  A label query over the set of namespaces that the term applies to.
                                                  The term is applied to the union of the namespaces selected by this field
                                                  and the ones listed in the namespaces field.
                                                  null selector and null or empty namespaces list means "this pod's namespace".
                                                  An empty selector ({}) matches all namespaces.
                                                properties:
                                                  matchExpressions:
                                                    description:
                                                      matchExpressions is
                                                      a list of label selector requirements.
                                                      The requirements are ANDed.
                                                    items:
                                                      description: |-
                                                        A label selector requirement is a selector that contains values, a key, and an operator that
                                                        relates the key and values.
                                                      properties:
                                                        key:
                                                          description:
                                                            key is the label
                                                            key that the selector applies
                                                            to.
                                                          type: string
                                                        operator:
                                                          description: |-
                                                            operator represents a key's relationship to a set of values.
                                                            Valid operators are In, NotIn, Exists and DoesNotExist.
                                                          type: string
                                                        values:
                                                          description: |-
                                                            values is an array of string values. If the operator is In or NotIn,
                                                            the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                            the values array must be empty. This array is replaced during a strategic
                                                            merge patch.
                                                          items:
                                                            type: string
                                                          type: array
                                                          x-kubernetes-list-type: atomic
                                                      required:
                                                        - key
                                                        - operator
                                                      type: object
                                                    type: array
                                                    x-kubernetes-list-type: atomic
                                                  matchLabels:
                                                    additionalProperties:
                                                      type: string
                                                    description: |-
                                                      matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                                      map is equivalent to an element of matchExpressions, whose key field is "key", the
                                                      operator is "In", and the values array contains only "value". The requirements are ANDed.
                                                    type: object
                                                type: object
                                                x-kubernetes-map-type: atomic
                                              namespaces:
                                                description: |-
                                                  namespaces specifies a static list of namespace names that the term applies to.
                                                  The term is applied to the union of the namespaces listed in this field
                                                  and the ones selected by namespaceSelector.
                                                  null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                items:
                                                  type: string
                                                type: array
                                                x-kubernetes-list-type: atomic
                                              topologyKey:
                                                description: |-
                                                  This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                  the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                  whose value of the label with key topologyKey matches that of any node on which any of the
                                                  selected pods is running.
                                                  Empty topologyKey is not allowed.
                                                type: string
                                            required:
                                              - topologyKey
                                            type: object
                                          type: array
                                          x-kubernetes-list-type: atomic
                                      type: object
                                  type: object
                                containers:
                                  items:
                                    description: |-
                                      GatewayDeploymentContainer allows customization of the resource requirements of gateway
                                      deployments.
                                      If GatewayDeployment.Spec.Template.Spec.Containers["envoy"].Resources is non-nil, it overrides
                                      the ResourceRequirements of the "envoy" container in each gateway deployment.
                                    properties:
                                      name:
                                        enum:
                                          - envoy
                                        type: string
                                      resources:
                                        description:
                                          ResourceRequirements describes
                                          the compute resource requirements.
                                        properties:
                                          claims:
                                            description: |-
                                              Claims lists the names of resources, defined in spec.resourceClaims,
                                              that are used by this container.
                                              This is an alpha field and requires enabling the
                                              DynamicResourceAllocation feature gate.
                                              This field is immutable. It can only be set for containers.
                                            items:
                                              description:
                                                ResourceClaim references
                                                one entry in PodSpec.ResourceClaims.
                                              properties:
                                                name:
                                                  description: |-
                                                    Name must match the name of one entry in pod.spec.resourceClaims of
                                                    the Pod where this field is used. It makes that resource available
                                                    inside a container.
                                                  type: string
                                                request:
                                                  description: |-
                                                    Request is the name chosen for a request in the referenced claim.
                                                    If empty, everything from the claim is made available, otherwise
                                                    only the result of this request.
                                                  type: string
                                              required:
                                                - name
                                              type: object
                                            type: array
                                            x-kubernetes-list-map-keys:
                                              - name
                                            x-kubernetes-list-type: map
                                          limits:
                                            additionalProperties:
                                              anyOf:
                                                - type: integer
                                                - type: string
                                              pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                              x-kubernetes-int-or-string: true
                                            description: |-
                                              Limits describes the maximum amount of compute resources allowed.
                                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                            type: object
                                          requests:
                                            additionalProperties:
                                              anyOf:
                                                - type: integer
                                                - type: string
                                              pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                              x-kubernetes-int-or-string: true
                                            description: |-
                                              Requests describes the minimum amount of compute resources required.
                                              If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                                              otherwise to an implementation-defined value. Requests cannot exceed Limits.
                                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                            type: object
                                        type: object
                                    required:
                                      - name
                                    type: object
                                  type: array
                                nodeSelector:
                                  additionalProperties:
                                    type: string
                                  type: object
                                tolerations:
                                  items:
                                    description: |-
                                      The pod this Toleration is attached to tolerates any taint that matches
                                      the triple <key,value,effect> using the matching operator <operator>.
                                    properties:
                                      effect:
                                        description: |-
                                          Effect indicates the taint effect to match. Empty means match all taint effects.
                                          When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
                                        type: string
                                      key:
                                        description: |-
                                          Key is the taint key that the toleration applies to. Empty means match all taint keys.
                                          If the key is empty, operator must be Exists; this combination means to match all values and all keys.
                                        type: string
                                      operator:
                                        description: |-
                                          Operator represents a key's relationship to the value.
                                          Valid operators are Exists and Equal. Defaults to Equal.
                                          Exists is equivalent to wildcard for value, so that a pod can
                                          tolerate all taints of a particular category.
                                        type: string
                                      tolerationSeconds:
                                        description: |-
                                          TolerationSeconds represents the period of time the toleration (which must be
                                          of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
                                          it is not set, which means tolerate the taint forever (do not evict). Zero and
                                          negative values will be treated as 0 (evict immediately) by the system.
                                        format: int64
                                        type: integer
                                      value:
                                        description: |-
                                          Value is the taint value the toleration matches to.
                                          If the operator is Exists, the value should be empty, otherwise just a regular string.
                                        type: string
                                    type: object
                                  type: array
                                topologySpreadConstraints:
                                  description: |-
                                    TopologySpreadConstraints describes how a group of pods ought to spread across topology
                                    domains. Scheduler will schedule pods in a way which abides by the constraints.
                                    All topologySpreadConstraints are ANDed.
                                  items:
                                    description:
                                      TopologySpreadConstraint specifies
                                      how to spread matching pods among the given topology.
                                    properties:
                                      labelSelector:
                                        description: |-
                                          LabelSelector is used to find matching pods.
                                          Pods that match this label selector are counted to determine the number of pods
                                          in their corresponding topology domain.
                                        properties:
                                          matchExpressions:
                                            description:
                                              matchExpressions is a list
                                              of label selector requirements. The requirements
                                              are ANDed.
                                            items:
                                              description: |-
                                                A label selector requirement is a selector that contains values, a key, and an operator that
                                                relates the key and values.
                                              properties:
                                                key:
                                                  description:
                                                    key is the label key
                                                    that the selector applies to.
                                                  type: string
                                                operator:
                                                  description: |-
                                                    operator represents a key's relationship to a set of values.
                                                    Valid operators are In, NotIn, Exists and DoesNotExist.
                                                  type: string
                                                values:
                                                  description: |-
                                                    values is an array of string values. If the operator is In or NotIn,
                                                    the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                    the values array must be empty. This array is replaced during a strategic
                                                    merge patch.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                              required:
                                                - key
                                                - operator
                                              type: object
                                            type: array
                                            x-kubernetes-list-type: atomic
                                          matchLabels:
                                            additionalProperties:
                                              type: string
                                            description: |-
                                              matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                              map is equivalent to an element of matchExpressions, whose key field is "key", the
                                              operator is "In", and the values array contains only "value". The requirements are ANDed.
                                            type: object
                                        type: object
                                        x-kubernetes-map-type: atomic
                                      matchLabelKeys:
                                        description: |-
                                          MatchLabelKeys is a set of pod label keys to select the pods over which
                                          spreading will be calculated. The keys are used to lookup values from the
                                          incoming pod labels, those key-value labels are ANDed with labelSelector
                                          to select the group of existing pods over which spreading will be calculated
                                          for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                          MatchLabelKeys cannot be set when LabelSelector isn't set.
                                          Keys that don't exist in the incoming pod labels will
                                          be ignored. A null or empty list means only match against labelSelector.
                                          This is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                      maxSkew:
                                        description: |-
                                          MaxSkew describes the degree to which pods may be unevenly distributed.
                                          When `whenUnsatisfiable=DoNotSchedule`, it is the maximum permitted difference
                                          between the number of matching pods in the target topology and the global minimum.
                                          The global minimum is the minimum number of matching pods in an eligible domain
                                          or zero if the number of eligible domains is less than MinDomains.
                                          For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same
                                          labelSelector spread as 2/2/1:
                                          In this case, the global minimum is 1.
                                          | zone1 | zone2 | zone3 |
                                          |  P P  |  P P  |   P   |
                                          - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2;
                                          scheduling it onto zone1(zone2) would make the ActualSkew(3-1) on zone1(zone2)
                                          violate MaxSkew(1).
                                          - if MaxSkew is 2, incoming pod can be scheduled onto any zone.
                                          When `whenUnsatisfiable=ScheduleAnyway`, it is used to give higher precedence
                                          to topologies that satisfy it.
                                          It's a required field. Default value is 1 and 0 is not allowed.
                                        format: int32
                                        type: integer
                                      minDomains:
                                        description: |-
                                          MinDomains indicates a minimum number of eligible domains.
                                          When the number of eligible domains with matching topology keys is less than minDomains,
                                          Pod Topology Spread treats "global minimum" as 0, and then the calculation of Skew is performed.
                                          And when the number of eligible domains with matching topology keys equals or greater than minDomains,
                                          this value has no effect on scheduling.
                                          As a result, when the number of eligible domains is less than minDomains,
                                          scheduler won't schedule more than maxSkew Pods to those domains.
                                          If value is nil, the constraint behaves as if MinDomains is equal to 1.
                                          Valid values are integers greater than 0.
                                          When value is not nil, WhenUnsatisfiable must be DoNotSchedule.
                                          For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same
                                          labelSelector spread as 2/2/2:
                                          | zone1 | zone2 | zone3 |
                                          |  P P  |  P P  |  P P  |
                                          The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0.
                                          In this situation, new pod with the same labelSelector cannot be scheduled,
                                          because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones,
                                          it will violate MaxSkew.
                                        format: int32
                                        type: integer
                                      nodeAffinityPolicy:
                                        description: |-
                                          NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector
                                          when calculating pod topology spread skew. Options are:
                                          - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations.
                                          - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.
                                          If this value is nil, the behavior is equivalent to the Honor policy.
                                          This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
                                        type: string
                                      nodeTaintsPolicy:
                                        description: |-
                                          NodeTaintsPolicy indicates how we will treat node taints when calculating
                                          pod topology spread skew. Options are:
                                          - Honor: nodes without taints, along with tainted nodes for which the incoming pod
                                          has a toleration, are included.
                                          - Ignore: node taints are ignored. All nodes are included.
                                          If this value is nil, the behavior is equivalent to the Ignore policy.
                                          This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
                                        type: string
                                      topologyKey:
                                        description: |-
                                          TopologyKey is the key of node labels. Nodes that have a label with this key
                                          and identical values are considered to be in the same topology.
                                          We consider each <key, value> as a "bucket", and try to put balanced number
                                          of pods into each bucket.
                                          We define a domain as a particular instance of a topology.
                                          Also, we define an eligible domain as a domain whose nodes meet the requirements of
                                          nodeAffinityPolicy and nodeTaintsPolicy.
                                          e.g. If TopologyKey is "kubernetes.io/hostname", each Node is a domain of that topology.
                                          And, if TopologyKey is "topology.kubernetes.io/zone", each zone is a domain of that topology.
                                          It's a required field.
                                        type: string
                                      whenUnsatisfiable:
                                        description: |-
                                          WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy
                                          the spread constraint.
                                          - DoNotSchedule (default) tells the scheduler not to schedule it.
                                          - ScheduleAnyway tells the scheduler to schedule the pod in any location,
                                            but giving higher precedence to topologies that would help reduce the
                                            skew.
                                          A constraint is considered "Unsatisfiable" for an incoming pod
                                          if and only if every possible node assignment for that pod would violate
                                          "MaxSkew" on some topology.
                                          For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same
                                          labelSelector spread as 3/1/1:
                                          | zone1 | zone2 | zone3 |
                                          | P P P |   P   |   P   |
                                          If WhenUnsatisfiable is set to DoNotSchedule, incoming pod can only be scheduled
                                          to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1) on zone2(zone3) satisfies
                                          MaxSkew(1). In other words, the cluster can still be imbalanced, but scheduler
                                          won't make it *more* imbalanced.
                                          It's a required field.
                                        type: string
                                    required:
                                      - maxSkew
                                      - topologyKey
                                      - whenUnsatisfiable
                                    type: object
                                  type: array
                              type: object
                          type: object
                      type: object
                  type: object
              type: object
          type: object
      served: true
      storage: true
