kind: CustomResourceDefinition
spec:
  group: spark.stackable.tech
  names:
    kind: SparkHistoryServer
    plural: sparkhistoryservers
    singular: sparkhistoryserver
    categories: []
    shortNames:
      - shs
  scope: Namespaced
  versions:
    - name: v1alpha1
      schema:
        openAPIV3Schema:
          type: object
          title: SparkHistoryServer
          required:
            - spec
          properties:
            spec:
              type: object
              required:
                - image
                - logFileDirectory
                - nodes
              properties:
                image:
                  type: object
                  anyOf:
                    - required:
                        - custom
                        - productVersion
                    - required:
                        - productVersion
                        - stackableVersion
                  properties:
                    repo:
                      type: string
                      nullable: true
                      description: Name of the docker repo, e.g. `docker.stackable.tech/stackable`
                    custom:
                      type: string
                      description: Overwrite the docker image. Specify the full docker image name,
                        e.g.
                        `docker.stackable.tech/stackable/superset:1.4.1-stackable2.1.0`
                    pullPolicy:
                      enum:
                        - IfNotPresent
                        - Always
                        - Never
                      type: string
                      default: IfNotPresent
                      description: "[Pull
                        policy](https://kubernetes.io/docs/concepts/containers/image\
                        s/#image-pull-policy) used when pulling the Images"
                    pullSecrets:
                      type: array
                      items:
                        type: object
                        properties:
                          name:
                            type: string
                            description: "Name of the referent. More info:
                              https://kubernetes.io/docs/concepts/overview/work\
                              ing-with-objects/names/#names"
                        description: LocalObjectReference contains enough information to let you locate
                          the referenced object inside the same namespace.
                      nullable: true
                      description: "[Image pull
                        secrets](https://kubernetes.io/docs/concepts/containers\
                        /images/#specifying-imagepullsecrets-on-a-pod) to pull
                        images from a private registry"
                    productVersion:
                      type: string
                      description: Version of the product, e.g. `1.4.1`.
                    stackableVersion:
                      type: string
                      description: Stackable version of the product, e.g. 2.1.0
                nodes:
                  type: object
                  required:
                    - roleGroups
                  properties:
                    config:
                      type: object
                      default: {}
                      properties:
                        cleaner:
                          type: boolean
                          nullable: true
                        logging:
                          type: object
                          default:
                            containers: {}
                            enableVectorAgent: null
                          properties:
                            containers:
                              type: object
                              additionalProperties:
                                type: object
                                anyOf:
                                  - required:
                                      - custom
                                  - {}
                                properties:
                                  file:
                                    type: object
                                    nullable: true
                                    properties:
                                      level:
                                        enum:
                                          - TRACE
                                          - DEBUG
                                          - INFO
                                          - WARN
                                          - ERROR
                                          - FATAL
                                          - NONE
                                        type: string
                                        nullable: true
                                        description: Log levels
                                  custom:
                                    type: object
                                    properties:
                                      configMap:
                                        type: string
                                        nullable: true
                                    description: Custom log configuration provided in a ConfigMap
                                  console:
                                    type: object
                                    nullable: true
                                    properties:
                                      level:
                                        enum:
                                          - TRACE
                                          - DEBUG
                                          - INFO
                                          - WARN
                                          - ERROR
                                          - FATAL
                                          - NONE
                                        type: string
                                        nullable: true
                                        description: Log levels
                                  loggers:
                                    type: object
                                    default: {}
                                    additionalProperties:
                                      type: object
                                      properties:
                                        level:
                                          enum:
                                            - TRACE
                                            - DEBUG
                                            - INFO
                                            - WARN
                                            - ERROR
                                            - FATAL
                                            - NONE
                                          type: string
                                          nullable: true
                                          description: Log levels
                                description: Fragment derived from `ContainerLogConfigChoice`
                            enableVectorAgent:
                              type: boolean
                              nullable: true
                        affinity:
                          type: object
                          default:
                            podAffinity: null
                            nodeAffinity: null
                            nodeSelector: null
                            podAntiAffinity: null
                          properties:
                            podAffinity:
                              type: object
                              nullable: true
                              properties:
                                requiredDuringSchedulingIgnoredDuringExecution:
                                  type: array
                                  items:
                                    type: object
                                    required:
                                      - topologyKey
                                    properties:
                                      namespaces:
                                        type: array
                                        items:
                                          type: string
                                        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".
                                      topologyKey:
                                        type: string
                                        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.
                                      labelSelector:
                                        type: object
                                        properties:
                                          matchLabels:
                                            type: object
                                            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.
                                            additionalProperties:
                                              type: string
                                          matchExpressions:
                                            type: array
                                            items:
                                              type: object
                                              required:
                                                - key
                                                - operator
                                              properties:
                                                key:
                                                  type: string
                                                  description: key is the label key that the selector applies to.
                                                values:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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.
                                                operator:
                                                  type: string
                                                  description: operator represents a key's relationship to a set of values. Valid
                                                    operators are In, NotIn,
                                                    Exists and DoesNotExist.
                                              description: A label selector requirement is a selector that contains values, a
                                                key, and an operator that
                                                relates the key and values.
                                            description: matchExpressions is a list of label selector requirements. The
                                              requirements are ANDed.
                                        description: A label query over a set of resources, in this case pods.
                                      namespaceSelector:
                                        type: object
                                        properties:
                                          matchLabels:
                                            type: object
                                            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.
                                            additionalProperties:
                                              type: string
                                          matchExpressions:
                                            type: array
                                            items:
                                              type: object
                                              required:
                                                - key
                                                - operator
                                              properties:
                                                key:
                                                  type: string
                                                  description: key is the label key that the selector applies to.
                                                values:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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.
                                                operator:
                                                  type: string
                                                  description: operator represents a key's relationship to a set of values. Valid
                                                    operators are In, NotIn,
                                                    Exists and DoesNotExist.
                                              description: A label selector requirement is a selector that contains values, a
                                                key, and an operator that
                                                relates the key and values.
                                            description: matchExpressions is a list of label selector requirements. The
                                              requirements are ANDed.
                                        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.
                                    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
                                  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.
                                preferredDuringSchedulingIgnoredDuringExecution:
                                  type: array
                                  items:
                                    type: object
                                    required:
                                      - podAffinityTerm
                                      - weight
                                    properties:
                                      weight:
                                        type: integer
                                        format: int32
                                        description: weight associated with matching the corresponding podAffinityTerm,
                                          in the range 1-100.
                                      podAffinityTerm:
                                        type: object
                                        required:
                                          - topologyKey
                                        properties:
                                          namespaces:
                                            type: array
                                            items:
                                              type: string
                                            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".
                                          topologyKey:
                                            type: string
                                            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.
                                          labelSelector:
                                            type: object
                                            properties:
                                              matchLabels:
                                                type: object
                                                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.
                                                additionalProperties:
                                                  type: string
                                              matchExpressions:
                                                type: array
                                                items:
                                                  type: object
                                                  required:
                                                    - key
                                                    - operator
                                                  properties:
                                                    key:
                                                      type: string
                                                      description: key is the label key that the selector applies to.
                                                    values:
                                                      type: array
                                                      items:
                                                        type: string
                                                      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.
                                                    operator:
                                                      type: string
                                                      description: operator represents a key's relationship to a set of values. Valid
                                                        operators are In, NotIn,
                                                        Exists and DoesNotExist.
                                                  description: A label selector requirement is a selector that contains values, a
                                                    key, and an operator that
                                                    relates the key and values.
                                                description: matchExpressions is a list of label selector requirements. The
                                                  requirements are ANDed.
                                            description: A label query over a set of resources, in this case pods.
                                          namespaceSelector:
                                            type: object
                                            properties:
                                              matchLabels:
                                                type: object
                                                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.
                                                additionalProperties:
                                                  type: string
                                              matchExpressions:
                                                type: array
                                                items:
                                                  type: object
                                                  required:
                                                    - key
                                                    - operator
                                                  properties:
                                                    key:
                                                      type: string
                                                      description: key is the label key that the selector applies to.
                                                    values:
                                                      type: array
                                                      items:
                                                        type: string
                                                      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.
                                                    operator:
                                                      type: string
                                                      description: operator represents a key's relationship to a set of values. Valid
                                                        operators are In, NotIn,
                                                        Exists and DoesNotExist.
                                                  description: A label selector requirement is a selector that contains values, a
                                                    key, and an operator that
                                                    relates the key and values.
                                                description: matchExpressions is a list of label selector requirements. The
                                                  requirements are ANDed.
                                            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.
                                        description: Required. A pod affinity term, associated with the corresponding
                                          weight.
                                    description: The weights of all of the matched WeightedPodAffinityTerm fields
                                      are added per-node to find the most
                                      preferred node(s)
                                  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.
                              description: Pod affinity is a group of inter pod affinity scheduling rules.
                            nodeAffinity:
                              type: object
                              nullable: true
                              properties:
                                requiredDuringSchedulingIgnoredDuringExecution:
                                  type: object
                                  required:
                                    - nodeSelectorTerms
                                  properties:
                                    nodeSelectorTerms:
                                      type: array
                                      items:
                                        type: object
                                        properties:
                                          matchFields:
                                            type: array
                                            items:
                                              type: object
                                              required:
                                                - key
                                                - operator
                                              properties:
                                                key:
                                                  type: string
                                                  description: The label key that the selector applies to.
                                                values:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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.
                                                operator:
                                                  type: string
                                                  description: >+
                                                    Represents a key's
                                                    relationship to a set of
                                                    values. Valid operators are
                                                    In, NotIn, Exists,
                                                    DoesNotExist. Gt, and Lt.

                                              description: A node selector requirement is a selector that contains values, a
                                                key, and an operator that
                                                relates the key and values.
                                            description: A list of node selector requirements by node's fields.
                                          matchExpressions:
                                            type: array
                                            items:
                                              type: object
                                              required:
                                                - key
                                                - operator
                                              properties:
                                                key:
                                                  type: string
                                                  description: The label key that the selector applies to.
                                                values:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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.
                                                operator:
                                                  type: string
                                                  description: >+
                                                    Represents a key's
                                                    relationship to a set of
                                                    values. Valid operators are
                                                    In, NotIn, Exists,
                                                    DoesNotExist. Gt, and Lt.

                                              description: A node selector requirement is a selector that contains values, a
                                                key, and an operator that
                                                relates the key and values.
                                            description: A list of node selector requirements by node's labels.
                                        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.
                                      description: Required. A list of node selector terms. The terms are ORed.
                                  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.
                                preferredDuringSchedulingIgnoredDuringExecution:
                                  type: array
                                  items:
                                    type: object
                                    required:
                                      - preference
                                      - weight
                                    properties:
                                      weight:
                                        type: integer
                                        format: int32
                                        description: Weight associated with matching the corresponding nodeSelectorTerm,
                                          in the range 1-100.
                                      preference:
                                        type: object
                                        properties:
                                          matchFields:
                                            type: array
                                            items:
                                              type: object
                                              required:
                                                - key
                                                - operator
                                              properties:
                                                key:
                                                  type: string
                                                  description: The label key that the selector applies to.
                                                values:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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.
                                                operator:
                                                  type: string
                                                  description: >+
                                                    Represents a key's
                                                    relationship to a set of
                                                    values. Valid operators are
                                                    In, NotIn, Exists,
                                                    DoesNotExist. Gt, and Lt.

                                              description: A node selector requirement is a selector that contains values, a
                                                key, and an operator that
                                                relates the key and values.
                                            description: A list of node selector requirements by node's fields.
                                          matchExpressions:
                                            type: array
                                            items:
                                              type: object
                                              required:
                                                - key
                                                - operator
                                              properties:
                                                key:
                                                  type: string
                                                  description: The label key that the selector applies to.
                                                values:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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.
                                                operator:
                                                  type: string
                                                  description: >+
                                                    Represents a key's
                                                    relationship to a set of
                                                    values. Valid operators are
                                                    In, NotIn, Exists,
                                                    DoesNotExist. Gt, and Lt.

                                              description: A node selector requirement is a selector that contains values, a
                                                key, and an operator that
                                                relates the key and values.
                                            description: A list of node selector requirements by node's labels.
                                        description: A node selector term, associated with the corresponding weight.
                                    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).
                                  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.
                              description: Node affinity is a group of node affinity scheduling rules.
                            nodeSelector:
                              type: object
                              nullable: true
                            podAntiAffinity:
                              type: object
                              nullable: true
                              properties:
                                requiredDuringSchedulingIgnoredDuringExecution:
                                  type: array
                                  items:
                                    type: object
                                    required:
                                      - topologyKey
                                    properties:
                                      namespaces:
                                        type: array
                                        items:
                                          type: string
                                        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".
                                      topologyKey:
                                        type: string
                                        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.
                                      labelSelector:
                                        type: object
                                        properties:
                                          matchLabels:
                                            type: object
                                            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.
                                            additionalProperties:
                                              type: string
                                          matchExpressions:
                                            type: array
                                            items:
                                              type: object
                                              required:
                                                - key
                                                - operator
                                              properties:
                                                key:
                                                  type: string
                                                  description: key is the label key that the selector applies to.
                                                values:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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.
                                                operator:
                                                  type: string
                                                  description: operator represents a key's relationship to a set of values. Valid
                                                    operators are In, NotIn,
                                                    Exists and DoesNotExist.
                                              description: A label selector requirement is a selector that contains values, a
                                                key, and an operator that
                                                relates the key and values.
                                            description: matchExpressions is a list of label selector requirements. The
                                              requirements are ANDed.
                                        description: A label query over a set of resources, in this case pods.
                                      namespaceSelector:
                                        type: object
                                        properties:
                                          matchLabels:
                                            type: object
                                            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.
                                            additionalProperties:
                                              type: string
                                          matchExpressions:
                                            type: array
                                            items:
                                              type: object
                                              required:
                                                - key
                                                - operator
                                              properties:
                                                key:
                                                  type: string
                                                  description: key is the label key that the selector applies to.
                                                values:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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.
                                                operator:
                                                  type: string
                                                  description: operator represents a key's relationship to a set of values. Valid
                                                    operators are In, NotIn,
                                                    Exists and DoesNotExist.
                                              description: A label selector requirement is a selector that contains values, a
                                                key, and an operator that
                                                relates the key and values.
                                            description: matchExpressions is a list of label selector requirements. The
                                              requirements are ANDed.
                                        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.
                                    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
                                  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.
                                preferredDuringSchedulingIgnoredDuringExecution:
                                  type: array
                                  items:
                                    type: object
                                    required:
                                      - podAffinityTerm
                                      - weight
                                    properties:
                                      weight:
                                        type: integer
                                        format: int32
                                        description: weight associated with matching the corresponding podAffinityTerm,
                                          in the range 1-100.
                                      podAffinityTerm:
                                        type: object
                                        required:
                                          - topologyKey
                                        properties:
                                          namespaces:
                                            type: array
                                            items:
                                              type: string
                                            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".
                                          topologyKey:
                                            type: string
                                            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.
                                          labelSelector:
                                            type: object
                                            properties:
                                              matchLabels:
                                                type: object
                                                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.
                                                additionalProperties:
                                                  type: string
                                              matchExpressions:
                                                type: array
                                                items:
                                                  type: object
                                                  required:
                                                    - key
                                                    - operator
                                                  properties:
                                                    key:
                                                      type: string
                                                      description: key is the label key that the selector applies to.
                                                    values:
                                                      type: array
                                                      items:
                                                        type: string
                                                      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.
                                                    operator:
                                                      type: string
                                                      description: operator represents a key's relationship to a set of values. Valid
                                                        operators are In, NotIn,
                                                        Exists and DoesNotExist.
                                                  description: A label selector requirement is a selector that contains values, a
                                                    key, and an operator that
                                                    relates the key and values.
                                                description: matchExpressions is a list of label selector requirements. The
                                                  requirements are ANDed.
                                            description: A label query over a set of resources, in this case pods.
                                          namespaceSelector:
                                            type: object
                                            properties:
                                              matchLabels:
                                                type: object
                                                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.
                                                additionalProperties:
                                                  type: string
                                              matchExpressions:
                                                type: array
                                                items:
                                                  type: object
                                                  required:
                                                    - key
                                                    - operator
                                                  properties:
                                                    key:
                                                      type: string
                                                      description: key is the label key that the selector applies to.
                                                    values:
                                                      type: array
                                                      items:
                                                        type: string
                                                      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.
                                                    operator:
                                                      type: string
                                                      description: operator represents a key's relationship to a set of values. Valid
                                                        operators are In, NotIn,
                                                        Exists and DoesNotExist.
                                                  description: A label selector requirement is a selector that contains values, a
                                                    key, and an operator that
                                                    relates the key and values.
                                                description: matchExpressions is a list of label selector requirements. The
                                                  requirements are ANDed.
                                            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.
                                        description: Required. A pod affinity term, associated with the corresponding
                                          weight.
                                    description: The weights of all of the matched WeightedPodAffinityTerm fields
                                      are added per-node to find the most
                                      preferred node(s)
                                  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.
                              description: Pod anti affinity is a group of inter pod anti affinity scheduling
                                rules.
                        resources:
                          type: object
                          default:
                            cpu:
                              max: null
                              min: null
                            memory:
                              limit: null
                              runtimeLimits: {}
                            storage: {}
                          properties:
                            cpu:
                              type: object
                              default:
                                max: null
                                min: null
                              properties:
                                max:
                                  type: string
                                  nullable: true
                                  description: >-
                                    Quantity is a fixed-point representation of
                                    a number. It provides convenient
                                    marshaling/unmarshaling in JSON and YAML, in
                                    addition to String() and AsInt64()
                                    accessors.


                                    The serialization format is:


                                    ``` <quantity>        ::=
                                    <signedNumber><suffix>

                                    	(Note that <suffix> may be empty, from the "" case in <decimalSI>.)

                                    <digit>           ::= 0 | 1 | ... | 9
                                    <digits>          ::= <digit> |
                                    <digit><digits> <number>          ::=
                                    <digits> | <digits>.<digits> | <digits>. |
                                    .<digits> <sign>            ::= "+" | "-"
                                    <signedNumber>    ::= <number> |
                                    <sign><number> <suffix>          ::=
                                    <binarySI> | <decimalExponent> | <decimalSI>
                                    <binarySI>        ::= Ki | Mi | Gi | Ti | Pi
                                    | Ei

                                    	(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)

                                    <decimalSI>       ::= m | "" | k | M | G | T
                                    | P | E

                                    	(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)

                                    <decimalExponent> ::= "e" <signedNumber> |
                                    "E" <signedNumber> ```


                                    No matter which of the three exponent forms
                                    is used, no quantity may represent a number
                                    greater than 2^63-1 in magnitude, nor may it
                                    have more than 3 decimal places. Numbers
                                    larger or more precise will be capped or
                                    rounded up. (E.g.: 0.1m will rounded up to
                                    1m.) This may be extended in the future if
                                    we require larger or smaller quantities.


                                    When a Quantity is parsed from a string, it
                                    will remember the type of suffix it had, and
                                    will use the same type again when it is
                                    serialized.


                                    Before serializing, Quantity will be put in
                                    "canonical form". This means that
                                    Exponent/suffix will be adjusted up or down
                                    (with a corresponding increase or decrease
                                    in Mantissa) such that:


                                    - No precision is lost - No fractional
                                    digits will be emitted - The exponent (or
                                    suffix) is as large as possible.


                                    The sign will be omitted unless the number
                                    is negative.


                                    Examples:


                                    - 1.5 will be serialized as "1500m" - 1.5Gi
                                    will be serialized as "1536Mi"


                                    Note that the quantity will NEVER be
                                    internally represented by a floating point
                                    number. That is the whole point of this
                                    exercise.


                                    Non-canonical values will still parse as
                                    long as they are well formed, but will be
                                    re-emitted in their canonical form. (So
                                    always use canonical form, or don't diff.)


                                    This format is intended to make it difficult
                                    to use these numbers without writing some
                                    sort of special handling code in the hopes
                                    that that will cause implementors to also
                                    use a fixed point implementation.
                                min:
                                  type: string
                                  nullable: true
                                  description: >-
                                    Quantity is a fixed-point representation of
                                    a number. It provides convenient
                                    marshaling/unmarshaling in JSON and YAML, in
                                    addition to String() and AsInt64()
                                    accessors.


                                    The serialization format is:


                                    ``` <quantity>        ::=
                                    <signedNumber><suffix>

                                    	(Note that <suffix> may be empty, from the "" case in <decimalSI>.)

                                    <digit>           ::= 0 | 1 | ... | 9
                                    <digits>          ::= <digit> |
                                    <digit><digits> <number>          ::=
                                    <digits> | <digits>.<digits> | <digits>. |
                                    .<digits> <sign>            ::= "+" | "-"
                                    <signedNumber>    ::= <number> |
                                    <sign><number> <suffix>          ::=
                                    <binarySI> | <decimalExponent> | <decimalSI>
                                    <binarySI>        ::= Ki | Mi | Gi | Ti | Pi
                                    | Ei

                                    	(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)

                                    <decimalSI>       ::= m | "" | k | M | G | T
                                    | P | E

                                    	(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)

                                    <decimalExponent> ::= "e" <signedNumber> |
                                    "E" <signedNumber> ```


                                    No matter which of the three exponent forms
                                    is used, no quantity may represent a number
                                    greater than 2^63-1 in magnitude, nor may it
                                    have more than 3 decimal places. Numbers
                                    larger or more precise will be capped or
                                    rounded up. (E.g.: 0.1m will rounded up to
                                    1m.) This may be extended in the future if
                                    we require larger or smaller quantities.


                                    When a Quantity is parsed from a string, it
                                    will remember the type of suffix it had, and
                                    will use the same type again when it is
                                    serialized.


                                    Before serializing, Quantity will be put in
                                    "canonical form". This means that
                                    Exponent/suffix will be adjusted up or down
                                    (with a corresponding increase or decrease
                                    in Mantissa) such that:


                                    - No precision is lost - No fractional
                                    digits will be emitted - The exponent (or
                                    suffix) is as large as possible.


                                    The sign will be omitted unless the number
                                    is negative.


                                    Examples:


                                    - 1.5 will be serialized as "1500m" - 1.5Gi
                                    will be serialized as "1536Mi"


                                    Note that the quantity will NEVER be
                                    internally represented by a floating point
                                    number. That is the whole point of this
                                    exercise.


                                    Non-canonical values will still parse as
                                    long as they are well formed, but will be
                                    re-emitted in their canonical form. (So
                                    always use canonical form, or don't diff.)


                                    This format is intended to make it difficult
                                    to use these numbers without writing some
                                    sort of special handling code in the hopes
                                    that that will cause implementors to also
                                    use a fixed point implementation.
                            memory:
                              type: object
                              properties:
                                limit:
                                  type: string
                                  nullable: true
                                  description: >-
                                    Quantity is a fixed-point representation of
                                    a number. It provides convenient
                                    marshaling/unmarshaling in JSON and YAML, in
                                    addition to String() and AsInt64()
                                    accessors.


                                    The serialization format is:


                                    ``` <quantity>        ::=
                                    <signedNumber><suffix>

                                    	(Note that <suffix> may be empty, from the "" case in <decimalSI>.)

                                    <digit>           ::= 0 | 1 | ... | 9
                                    <digits>          ::= <digit> |
                                    <digit><digits> <number>          ::=
                                    <digits> | <digits>.<digits> | <digits>. |
                                    .<digits> <sign>            ::= "+" | "-"
                                    <signedNumber>    ::= <number> |
                                    <sign><number> <suffix>          ::=
                                    <binarySI> | <decimalExponent> | <decimalSI>
                                    <binarySI>        ::= Ki | Mi | Gi | Ti | Pi
                                    | Ei

                                    	(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)

                                    <decimalSI>       ::= m | "" | k | M | G | T
                                    | P | E

                                    	(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)

                                    <decimalExponent> ::= "e" <signedNumber> |
                                    "E" <signedNumber> ```


                                    No matter which of the three exponent forms
                                    is used, no quantity may represent a number
                                    greater than 2^63-1 in magnitude, nor may it
                                    have more than 3 decimal places. Numbers
                                    larger or more precise will be capped or
                                    rounded up. (E.g.: 0.1m will rounded up to
                                    1m.) This may be extended in the future if
                                    we require larger or smaller quantities.


                                    When a Quantity is parsed from a string, it
                                    will remember the type of suffix it had, and
                                    will use the same type again when it is
                                    serialized.


                                    Before serializing, Quantity will be put in
                                    "canonical form". This means that
                                    Exponent/suffix will be adjusted up or down
                                    (with a corresponding increase or decrease
                                    in Mantissa) such that:


                                    - No precision is lost - No fractional
                                    digits will be emitted - The exponent (or
                                    suffix) is as large as possible.


                                    The sign will be omitted unless the number
                                    is negative.


                                    Examples:


                                    - 1.5 will be serialized as "1500m" - 1.5Gi
                                    will be serialized as "1536Mi"


                                    Note that the quantity will NEVER be
                                    internally represented by a floating point
                                    number. That is the whole point of this
                                    exercise.


                                    Non-canonical values will still parse as
                                    long as they are well formed, but will be
                                    re-emitted in their canonical form. (So
                                    always use canonical form, or don't diff.)


                                    This format is intended to make it difficult
                                    to use these numbers without writing some
                                    sort of special handling code in the hopes
                                    that that will cause implementors to also
                                    use a fixed point implementation.
                                runtimeLimits:
                                  type: object
                            storage:
                              type: object
                    roleGroups:
                      type: object
                      additionalProperties:
                        type: object
                        properties:
                          config:
                            type: object
                            default: {}
                            properties:
                              cleaner:
                                type: boolean
                                nullable: true
                              logging:
                                type: object
                                default:
                                  containers: {}
                                  enableVectorAgent: null
                                properties:
                                  containers:
                                    type: object
                                    additionalProperties:
                                      type: object
                                      anyOf:
                                        - required:
                                            - custom
                                        - {}
                                      properties:
                                        file:
                                          type: object
                                          nullable: true
                                          properties:
                                            level:
                                              enum:
                                                - TRACE
                                                - DEBUG
                                                - INFO
                                                - WARN
                                                - ERROR
                                                - FATAL
                                                - NONE
                                              type: string
                                              nullable: true
                                              description: Log levels
                                        custom:
                                          type: object
                                          properties:
                                            configMap:
                                              type: string
                                              nullable: true
                                          description: Custom log configuration provided in a ConfigMap
                                        console:
                                          type: object
                                          nullable: true
                                          properties:
                                            level:
                                              enum:
                                                - TRACE
                                                - DEBUG
                                                - INFO
                                                - WARN
                                                - ERROR
                                                - FATAL
                                                - NONE
                                              type: string
                                              nullable: true
                                              description: Log levels
                                        loggers:
                                          type: object
                                          default: {}
                                          additionalProperties:
                                            type: object
                                            properties:
                                              level:
                                                enum:
                                                  - TRACE
                                                  - DEBUG
                                                  - INFO
                                                  - WARN
                                                  - ERROR
                                                  - FATAL
                                                  - NONE
                                                type: string
                                                nullable: true
                                                description: Log levels
                                      description: Fragment derived from `ContainerLogConfigChoice`
                                  enableVectorAgent:
                                    type: boolean
                                    nullable: true
                              affinity:
                                type: object
                                default:
                                  podAffinity: null
                                  nodeAffinity: null
                                  nodeSelector: null
                                  podAntiAffinity: null
                                properties:
                                  podAffinity:
                                    type: object
                                    nullable: true
                                    properties:
                                      requiredDuringSchedulingIgnoredDuringExecution:
                                        type: array
                                        items:
                                          type: object
                                          required:
                                            - topologyKey
                                          properties:
                                            namespaces:
                                              type: array
                                              items:
                                                type: string
                                              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".
                                            topologyKey:
                                              type: string
                                              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.
                                            labelSelector:
                                              type: object
                                              properties:
                                                matchLabels:
                                                  type: object
                                                  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.
                                                  additionalProperties:
                                                    type: string
                                                matchExpressions:
                                                  type: array
                                                  items:
                                                    type: object
                                                    required:
                                                      - key
                                                      - operator
                                                    properties:
                                                      key:
                                                        type: string
                                                        description: key is the label key that the selector applies to.
                                                      values:
                                                        type: array
                                                        items:
                                                          type: string
                                                        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.
                                                      operator:
                                                        type: string
                                                        description: operator represents a key's relationship to a set of values. Valid
                                                          operators are In,
                                                          NotIn, Exists and
                                                          DoesNotExist.
                                                    description: A label selector requirement is a selector that contains values, a
                                                      key, and an operator that
                                                      relates the key and
                                                      values.
                                                  description: matchExpressions is a list of label selector requirements. The
                                                    requirements are ANDed.
                                              description: A label query over a set of resources, in this case pods.
                                            namespaceSelector:
                                              type: object
                                              properties:
                                                matchLabels:
                                                  type: object
                                                  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.
                                                  additionalProperties:
                                                    type: string
                                                matchExpressions:
                                                  type: array
                                                  items:
                                                    type: object
                                                    required:
                                                      - key
                                                      - operator
                                                    properties:
                                                      key:
                                                        type: string
                                                        description: key is the label key that the selector applies to.
                                                      values:
                                                        type: array
                                                        items:
                                                          type: string
                                                        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.
                                                      operator:
                                                        type: string
                                                        description: operator represents a key's relationship to a set of values. Valid
                                                          operators are In,
                                                          NotIn, Exists and
                                                          DoesNotExist.
                                                    description: A label selector requirement is a selector that contains values, a
                                                      key, and an operator that
                                                      relates the key and
                                                      values.
                                                  description: matchExpressions is a list of label selector requirements. The
                                                    requirements are ANDed.
                                              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.
                                          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
                                        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.
                                      preferredDuringSchedulingIgnoredDuringExecution:
                                        type: array
                                        items:
                                          type: object
                                          required:
                                            - podAffinityTerm
                                            - weight
                                          properties:
                                            weight:
                                              type: integer
                                              format: int32
                                              description: weight associated with matching the corresponding podAffinityTerm,
                                                in the range 1-100.
                                            podAffinityTerm:
                                              type: object
                                              required:
                                                - topologyKey
                                              properties:
                                                namespaces:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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".
                                                topologyKey:
                                                  type: string
                                                  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.
                                                labelSelector:
                                                  type: object
                                                  properties:
                                                    matchLabels:
                                                      type: object
                                                      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.
                                                      additionalProperties:
                                                        type: string
                                                    matchExpressions:
                                                      type: array
                                                      items:
                                                        type: object
                                                        required:
                                                          - key
                                                          - operator
                                                        properties:
                                                          key:
                                                            type: string
                                                            description: key is the label key that the selector applies to.
                                                          values:
                                                            type: array
                                                            items:
                                                              type: string
                                                            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.
                                                          operator:
                                                            type: string
                                                            description: operator represents a key's relationship to a set of values. Valid
                                                              operators are In,
                                                              NotIn, Exists and
                                                              DoesNotExist.
                                                        description: A label selector requirement is a selector that contains values, a
                                                          key, and an operator
                                                          that relates the key
                                                          and values.
                                                      description: matchExpressions is a list of label selector requirements. The
                                                        requirements are ANDed.
                                                  description: A label query over a set of resources, in this case pods.
                                                namespaceSelector:
                                                  type: object
                                                  properties:
                                                    matchLabels:
                                                      type: object
                                                      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.
                                                      additionalProperties:
                                                        type: string
                                                    matchExpressions:
                                                      type: array
                                                      items:
                                                        type: object
                                                        required:
                                                          - key
                                                          - operator
                                                        properties:
                                                          key:
                                                            type: string
                                                            description: key is the label key that the selector applies to.
                                                          values:
                                                            type: array
                                                            items:
                                                              type: string
                                                            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.
                                                          operator:
                                                            type: string
                                                            description: operator represents a key's relationship to a set of values. Valid
                                                              operators are In,
                                                              NotIn, Exists and
                                                              DoesNotExist.
                                                        description: A label selector requirement is a selector that contains values, a
                                                          key, and an operator
                                                          that relates the key
                                                          and values.
                                                      description: matchExpressions is a list of label selector requirements. The
                                                        requirements are ANDed.
                                                  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.
                                              description: Required. A pod affinity term, associated with the corresponding
                                                weight.
                                          description: The weights of all of the matched WeightedPodAffinityTerm fields
                                            are added per-node to find the most
                                            preferred node(s)
                                        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.
                                    description: Pod affinity is a group of inter pod affinity scheduling rules.
                                  nodeAffinity:
                                    type: object
                                    nullable: true
                                    properties:
                                      requiredDuringSchedulingIgnoredDuringExecution:
                                        type: object
                                        required:
                                          - nodeSelectorTerms
                                        properties:
                                          nodeSelectorTerms:
                                            type: array
                                            items:
                                              type: object
                                              properties:
                                                matchFields:
                                                  type: array
                                                  items:
                                                    type: object
                                                    required:
                                                      - key
                                                      - operator
                                                    properties:
                                                      key:
                                                        type: string
                                                        description: The label key that the selector applies to.
                                                      values:
                                                        type: array
                                                        items:
                                                          type: string
                                                        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.
                                                      operator:
                                                        type: string
                                                        description: >+
                                                          Represents a key's
                                                          relationship to a set
                                                          of values. Valid
                                                          operators are In,
                                                          NotIn, Exists,
                                                          DoesNotExist. Gt, and
                                                          Lt.

                                                    description: A node selector requirement is a selector that contains values, a
                                                      key, and an operator that
                                                      relates the key and
                                                      values.
                                                  description: A list of node selector requirements by node's fields.
                                                matchExpressions:
                                                  type: array
                                                  items:
                                                    type: object
                                                    required:
                                                      - key
                                                      - operator
                                                    properties:
                                                      key:
                                                        type: string
                                                        description: The label key that the selector applies to.
                                                      values:
                                                        type: array
                                                        items:
                                                          type: string
                                                        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.
                                                      operator:
                                                        type: string
                                                        description: >+
                                                          Represents a key's
                                                          relationship to a set
                                                          of values. Valid
                                                          operators are In,
                                                          NotIn, Exists,
                                                          DoesNotExist. Gt, and
                                                          Lt.

                                                    description: A node selector requirement is a selector that contains values, a
                                                      key, and an operator that
                                                      relates the key and
                                                      values.
                                                  description: A list of node selector requirements by node's labels.
                                              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.
                                            description: Required. A list of node selector terms. The terms are ORed.
                                        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.
                                      preferredDuringSchedulingIgnoredDuringExecution:
                                        type: array
                                        items:
                                          type: object
                                          required:
                                            - preference
                                            - weight
                                          properties:
                                            weight:
                                              type: integer
                                              format: int32
                                              description: Weight associated with matching the corresponding nodeSelectorTerm,
                                                in the range 1-100.
                                            preference:
                                              type: object
                                              properties:
                                                matchFields:
                                                  type: array
                                                  items:
                                                    type: object
                                                    required:
                                                      - key
                                                      - operator
                                                    properties:
                                                      key:
                                                        type: string
                                                        description: The label key that the selector applies to.
                                                      values:
                                                        type: array
                                                        items:
                                                          type: string
                                                        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.
                                                      operator:
                                                        type: string
                                                        description: >+
                                                          Represents a key's
                                                          relationship to a set
                                                          of values. Valid
                                                          operators are In,
                                                          NotIn, Exists,
                                                          DoesNotExist. Gt, and
                                                          Lt.

                                                    description: A node selector requirement is a selector that contains values, a
                                                      key, and an operator that
                                                      relates the key and
                                                      values.
                                                  description: A list of node selector requirements by node's fields.
                                                matchExpressions:
                                                  type: array
                                                  items:
                                                    type: object
                                                    required:
                                                      - key
                                                      - operator
                                                    properties:
                                                      key:
                                                        type: string
                                                        description: The label key that the selector applies to.
                                                      values:
                                                        type: array
                                                        items:
                                                          type: string
                                                        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.
                                                      operator:
                                                        type: string
                                                        description: >+
                                                          Represents a key's
                                                          relationship to a set
                                                          of values. Valid
                                                          operators are In,
                                                          NotIn, Exists,
                                                          DoesNotExist. Gt, and
                                                          Lt.

                                                    description: A node selector requirement is a selector that contains values, a
                                                      key, and an operator that
                                                      relates the key and
                                                      values.
                                                  description: A list of node selector requirements by node's labels.
                                              description: A node selector term, associated with the corresponding weight.
                                          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).
                                        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.
                                    description: Node affinity is a group of node affinity scheduling rules.
                                  nodeSelector:
                                    type: object
                                    nullable: true
                                  podAntiAffinity:
                                    type: object
                                    nullable: true
                                    properties:
                                      requiredDuringSchedulingIgnoredDuringExecution:
                                        type: array
                                        items:
                                          type: object
                                          required:
                                            - topologyKey
                                          properties:
                                            namespaces:
                                              type: array
                                              items:
                                                type: string
                                              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".
                                            topologyKey:
                                              type: string
                                              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.
                                            labelSelector:
                                              type: object
                                              properties:
                                                matchLabels:
                                                  type: object
                                                  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.
                                                  additionalProperties:
                                                    type: string
                                                matchExpressions:
                                                  type: array
                                                  items:
                                                    type: object
                                                    required:
                                                      - key
                                                      - operator
                                                    properties:
                                                      key:
                                                        type: string
                                                        description: key is the label key that the selector applies to.
                                                      values:
                                                        type: array
                                                        items:
                                                          type: string
                                                        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.
                                                      operator:
                                                        type: string
                                                        description: operator represents a key's relationship to a set of values. Valid
                                                          operators are In,
                                                          NotIn, Exists and
                                                          DoesNotExist.
                                                    description: A label selector requirement is a selector that contains values, a
                                                      key, and an operator that
                                                      relates the key and
                                                      values.
                                                  description: matchExpressions is a list of label selector requirements. The
                                                    requirements are ANDed.
                                              description: A label query over a set of resources, in this case pods.
                                            namespaceSelector:
                                              type: object
                                              properties:
                                                matchLabels:
                                                  type: object
                                                  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.
                                                  additionalProperties:
                                                    type: string
                                                matchExpressions:
                                                  type: array
                                                  items:
                                                    type: object
                                                    required:
                                                      - key
                                                      - operator
                                                    properties:
                                                      key:
                                                        type: string
                                                        description: key is the label key that the selector applies to.
                                                      values:
                                                        type: array
                                                        items:
                                                          type: string
                                                        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.
                                                      operator:
                                                        type: string
                                                        description: operator represents a key's relationship to a set of values. Valid
                                                          operators are In,
                                                          NotIn, Exists and
                                                          DoesNotExist.
                                                    description: A label selector requirement is a selector that contains values, a
                                                      key, and an operator that
                                                      relates the key and
                                                      values.
                                                  description: matchExpressions is a list of label selector requirements. The
                                                    requirements are ANDed.
                                              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.
                                          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
                                        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.
                                      preferredDuringSchedulingIgnoredDuringExecution:
                                        type: array
                                        items:
                                          type: object
                                          required:
                                            - podAffinityTerm
                                            - weight
                                          properties:
                                            weight:
                                              type: integer
                                              format: int32
                                              description: weight associated with matching the corresponding podAffinityTerm,
                                                in the range 1-100.
                                            podAffinityTerm:
                                              type: object
                                              required:
                                                - topologyKey
                                              properties:
                                                namespaces:
                                                  type: array
                                                  items:
                                                    type: string
                                                  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".
                                                topologyKey:
                                                  type: string
                                                  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.
                                                labelSelector:
                                                  type: object
                                                  properties:
                                                    matchLabels:
                                                      type: object
                                                      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.
                                                      additionalProperties:
                                                        type: string
                                                    matchExpressions:
                                                      type: array
                                                      items:
                                                        type: object
                                                        required:
                                                          - key
                                                          - operator
                                                        properties:
                                                          key:
                                                            type: string
                                                            description: key is the label key that the selector applies to.
                                                          values:
                                                            type: array
                                                            items:
                                                              type: string
                                                            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.
                                                          operator:
                                                            type: string
                                                            description: operator represents a key's relationship to a set of values. Valid
                                                              operators are In,
                                                              NotIn, Exists and
                                                              DoesNotExist.
                                                        description: A label selector requirement is a selector that contains values, a
                                                          key, and an operator
                                                          that relates the key
                                                          and values.
                                                      description: matchExpressions is a list of label selector requirements. The
                                                        requirements are ANDed.
                                                  description: A label query over a set of resources, in this case pods.
                                                namespaceSelector:
                                                  type: object
                                                  properties:
                                                    matchLabels:
                                                      type: object
                                                      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.
                                                      additionalProperties:
                                                        type: string
                                                    matchExpressions:
                                                      type: array
                                                      items:
                                                        type: object
                                                        required:
                                                          - key
                                                          - operator
                                                        properties:
                                                          key:
                                                            type: string
                                                            description: key is the label key that the selector applies to.
                                                          values:
                                                            type: array
                                                            items:
                                                              type: string
                                                            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.
                                                          operator:
                                                            type: string
                                                            description: operator represents a key's relationship to a set of values. Valid
                                                              operators are In,
                                                              NotIn, Exists and
                                                              DoesNotExist.
                                                        description: A label selector requirement is a selector that contains values, a
                                                          key, and an operator
                                                          that relates the key
                                                          and values.
                                                      description: matchExpressions is a list of label selector requirements. The
                                                        requirements are ANDed.
                                                  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.
                                              description: Required. A pod affinity term, associated with the corresponding
                                                weight.
                                          description: The weights of all of the matched WeightedPodAffinityTerm fields
                                            are added per-node to find the most
                                            preferred node(s)
                                        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.
                                    description: Pod anti affinity is a group of inter pod anti affinity scheduling
                                      rules.
                              resources:
                                type: object
                                default:
                                  cpu:
                                    max: null
                                    min: null
                                  memory:
                                    limit: null
                                    runtimeLimits: {}
                                  storage: {}
                                properties:
                                  cpu:
                                    type: object
                                    default:
                                      max: null
                                      min: null
                                    properties:
                                      max:
                                        type: string
                                        nullable: true
                                        description: >-
                                          Quantity is a fixed-point
                                          representation of a number. It
                                          provides convenient
                                          marshaling/unmarshaling in JSON and
                                          YAML, in addition to String() and
                                          AsInt64() accessors.


                                          The serialization format is:


                                          ``` <quantity>        ::=
                                          <signedNumber><suffix>

                                          	(Note that <suffix> may be empty, from the "" case in <decimalSI>.)

                                          <digit>           ::= 0 | 1 | ... | 9
                                          <digits>          ::= <digit> |
                                          <digit><digits> <number>          ::=
                                          <digits> | <digits>.<digits> |
                                          <digits>. | .<digits>
                                          <sign>            ::= "+" | "-"
                                          <signedNumber>    ::= <number> |
                                          <sign><number> <suffix>          ::=
                                          <binarySI> | <decimalExponent> |
                                          <decimalSI> <binarySI>        ::= Ki |
                                          Mi | Gi | Ti | Pi | Ei

                                          	(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)

                                          <decimalSI>       ::= m | "" | k | M |
                                          G | T | P | E

                                          	(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)

                                          <decimalExponent> ::= "e"
                                          <signedNumber> | "E" <signedNumber>
                                          ```


                                          No matter which of the three exponent
                                          forms is used, no quantity may
                                          represent a number greater than 2^63-1
                                          in magnitude, nor may it have more
                                          than 3 decimal places. Numbers larger
                                          or more precise will be capped or
                                          rounded up. (E.g.: 0.1m will rounded
                                          up to 1m.) This may be extended in the
                                          future if we require larger or smaller
                                          quantities.


                                          When a Quantity is parsed from a
                                          string, it will remember the type of
                                          suffix it had, and will use the same
                                          type again when it is serialized.


                                          Before serializing, Quantity will be
                                          put in "canonical form". This means
                                          that Exponent/suffix will be adjusted
                                          up or down (with a corresponding
                                          increase or decrease in Mantissa) such
                                          that:


                                          - No precision is lost - No fractional
                                          digits will be emitted - The exponent
                                          (or suffix) is as large as possible.


                                          The sign will be omitted unless the
                                          number is negative.


                                          Examples:


                                          - 1.5 will be serialized as "1500m" -
                                          1.5Gi will be serialized as "1536Mi"


                                          Note that the quantity will NEVER be
                                          internally represented by a floating
                                          point number. That is the whole point
                                          of this exercise.


                                          Non-canonical values will still parse
                                          as long as they are well formed, but
                                          will be re-emitted in their canonical
                                          form. (So always use canonical form,
                                          or don't diff.)


                                          This format is intended to make it
                                          difficult to use these numbers without
                                          writing some sort of special handling
                                          code in the hopes that that will cause
                                          implementors to also use a fixed point
                                          implementation.
                                      min:
                                        type: string
                                        nullable: true
                                        description: >-
                                          Quantity is a fixed-point
                                          representation of a number. It
                                          provides convenient
                                          marshaling/unmarshaling in JSON and
                                          YAML, in addition to String() and
                                          AsInt64() accessors.


                                          The serialization format is:


                                          ``` <quantity>        ::=
                                          <signedNumber><suffix>

                                          	(Note that <suffix> may be empty, from the "" case in <decimalSI>.)

                                          <digit>           ::= 0 | 1 | ... | 9
                                          <digits>          ::= <digit> |
                                          <digit><digits> <number>          ::=
                                          <digits> | <digits>.<digits> |
                                          <digits>. | .<digits>
                                          <sign>            ::= "+" | "-"
                                          <signedNumber>    ::= <number> |
                                          <sign><number> <suffix>          ::=
                                          <binarySI> | <decimalExponent> |
                                          <decimalSI> <binarySI>        ::= Ki |
                                          Mi | Gi | Ti | Pi | Ei

                                          	(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)

                                          <decimalSI>       ::= m | "" | k | M |
                                          G | T | P | E

                                          	(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)

                                          <decimalExponent> ::= "e"
                                          <signedNumber> | "E" <signedNumber>
                                          ```


                                          No matter which of the three exponent
                                          forms is used, no quantity may
                                          represent a number greater than 2^63-1
                                          in magnitude, nor may it have more
                                          than 3 decimal places. Numbers larger
                                          or more precise will be capped or
                                          rounded up. (E.g.: 0.1m will rounded
                                          up to 1m.) This may be extended in the
                                          future if we require larger or smaller
                                          quantities.


                                          When a Quantity is parsed from a
                                          string, it will remember the type of
                                          suffix it had, and will use the same
                                          type again when it is serialized.


                                          Before serializing, Quantity will be
                                          put in "canonical form". This means
                                          that Exponent/suffix will be adjusted
                                          up or down (with a corresponding
                                          increase or decrease in Mantissa) such
                                          that:


                                          - No precision is lost - No fractional
                                          digits will be emitted - The exponent
                                          (or suffix) is as large as possible.


                                          The sign will be omitted unless the
                                          number is negative.


                                          Examples:


                                          - 1.5 will be serialized as "1500m" -
                                          1.5Gi will be serialized as "1536Mi"


                                          Note that the quantity will NEVER be
                                          internally represented by a floating
                                          point number. That is the whole point
                                          of this exercise.


                                          Non-canonical values will still parse
                                          as long as they are well formed, but
                                          will be re-emitted in their canonical
                                          form. (So always use canonical form,
                                          or don't diff.)


                                          This format is intended to make it
                                          difficult to use these numbers without
                                          writing some sort of special handling
                                          code in the hopes that that will cause
                                          implementors to also use a fixed point
                                          implementation.
                                  memory:
                                    type: object
                                    properties:
                                      limit:
                                        type: string
                                        nullable: true
                                        description: >-
                                          Quantity is a fixed-point
                                          representation of a number. It
                                          provides convenient
                                          marshaling/unmarshaling in JSON and
                                          YAML, in addition to String() and
                                          AsInt64() accessors.


                                          The serialization format is:


                                          ``` <quantity>        ::=
                                          <signedNumber><suffix>

                                          	(Note that <suffix> may be empty, from the "" case in <decimalSI>.)

                                          <digit>           ::= 0 | 1 | ... | 9
                                          <digits>          ::= <digit> |
                                          <digit><digits> <number>          ::=
                                          <digits> | <digits>.<digits> |
                                          <digits>. | .<digits>
                                          <sign>            ::= "+" | "-"
                                          <signedNumber>    ::= <number> |
                                          <sign><number> <suffix>          ::=
                                          <binarySI> | <decimalExponent> |
                                          <decimalSI> <binarySI>        ::= Ki |
                                          Mi | Gi | Ti | Pi | Ei

                                          	(International System of units; See: http://physics.nist.gov/cuu/Units/binary.html)

                                          <decimalSI>       ::= m | "" | k | M |
                                          G | T | P | E

                                          	(Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the capitalization.)

                                          <decimalExponent> ::= "e"
                                          <signedNumber> | "E" <signedNumber>
                                          ```


                                          No matter which of the three exponent
                                          forms is used, no quantity may
                                          represent a number greater than 2^63-1
                                          in magnitude, nor may it have more
                                          than 3 decimal places. Numbers larger
                                          or more precise will be capped or
                                          rounded up. (E.g.: 0.1m will rounded
                                          up to 1m.) This may be extended in the
                                          future if we require larger or smaller
                                          quantities.


                                          When a Quantity is parsed from a
                                          string, it will remember the type of
                                          suffix it had, and will use the same
                                          type again when it is serialized.


                                          Before serializing, Quantity will be
                                          put in "canonical form". This means
                                          that Exponent/suffix will be adjusted
                                          up or down (with a corresponding
                                          increase or decrease in Mantissa) such
                                          that:


                                          - No precision is lost - No fractional
                                          digits will be emitted - The exponent
                                          (or suffix) is as large as possible.


                                          The sign will be omitted unless the
                                          number is negative.


                                          Examples:


                                          - 1.5 will be serialized as "1500m" -
                                          1.5Gi will be serialized as "1536Mi"


                                          Note that the quantity will NEVER be
                                          internally represented by a floating
                                          point number. That is the whole point
                                          of this exercise.


                                          Non-canonical values will still parse
                                          as long as they are well formed, but
                                          will be re-emitted in their canonical
                                          form. (So always use canonical form,
                                          or don't diff.)


                                          This format is intended to make it
                                          difficult to use these numbers without
                                          writing some sort of special handling
                                          code in the hopes that that will cause
                                          implementors to also use a fixed point
                                          implementation.
                                      runtimeLimits:
                                        type: object
                                  storage:
                                    type: object
                          replicas:
                            type: integer
                            format: uint16
                            minimum: 0
                            nullable: true
                          selector:
                            type: object
                            nullable: true
                            properties:
                              matchLabels:
                                type: object
                                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.
                                additionalProperties:
                                  type: string
                              matchExpressions:
                                type: array
                                items:
                                  type: object
                                  required:
                                    - key
                                    - operator
                                  properties:
                                    key:
                                      type: string
                                      description: key is the label key that the selector applies to.
                                    values:
                                      type: array
                                      items:
                                        type: string
                                      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.
                                    operator:
                                      type: string
                                      description: operator represents a key's relationship to a set of values. Valid
                                        operators are In, NotIn, Exists and
                                        DoesNotExist.
                                  description: A label selector requirement is a selector that contains values, a
                                    key, and an operator that relates the key
                                    and values.
                                description: matchExpressions is a list of label selector requirements. The
                                  requirements are ANDed.
                            description: A label selector is a label query over a set of resources. The
                              result of matchLabels and matchExpressions are
                              ANDed. An empty label selector matches all
                              objects. A null label selector matches no objects.
                          cliOverrides:
                            type: object
                            default: {}
                            additionalProperties:
                              type: string
                          envOverrides:
                            type: object
                            default: {}
                            additionalProperties:
                              type: string
                          configOverrides:
                            type: object
                            default: {}
                            additionalProperties:
                              type: object
                              additionalProperties:
                                type: string
                    cliOverrides:
                      type: object
                      default: {}
                      additionalProperties:
                        type: string
                    envOverrides:
                      type: object
                      default: {}
                      additionalProperties:
                        type: string
                    configOverrides:
                      type: object
                      default: {}
                      additionalProperties:
                        type: object
                        additionalProperties:
                          type: string
                sparkConf:
                  type: object
                  nullable: true
                  additionalProperties:
                    type: string
                clusterConfig:
                  type: object
                  default:
                    listenerClass: cluster-internal
                  properties:
                    listenerClass:
                      enum:
                        - cluster-internal
                        - external-unstable
                        - external-stable
                      type: string
                      default: cluster-internal
                      description: |-
                        In the future this setting will control, which ListenerClass <https://docs.stackable.tech/home/stable/listener-operator/listenerclass.html> will be used to expose the service. Currently only a subset of the ListenerClasses are supported by choosing the type of the created Services by looking at the ListenerClass name specified, In a future release support for custom ListenerClasses will be introduced without a breaking change:

                        * cluster-internal: Use a ClusterIP service

                        * external-unstable: Use a NodePort service

                        * external-stable: Use a LoadBalancer service
                  description: Global Spark history server configuration that applies to all roles
                    and role groups
                logFileDirectory:
                  type: object
                  oneOf:
                    - required:
                        - s3
                  properties:
                    s3:
                      type: object
                      required:
                        - bucket
                        - prefix
                      properties:
                        bucket:
                          type: object
                          oneOf:
                            - required:
                                - inline
                            - required:
                                - reference
                          properties:
                            inline:
                              type: object
                              properties:
                                bucketName:
                                  type: string
                                  nullable: true
                                connection:
                                  type: object
                                  oneOf:
                                    - required:
                                        - inline
                                    - required:
                                        - reference
                                  nullable: true
                                  properties:
                                    inline:
                                      type: object
                                      properties:
                                        tls:
                                          type: object
                                          nullable: true
                                          required:
                                            - verification
                                          properties:
                                            verification:
                                              type: object
                                              oneOf:
                                                - required:
                                                    - none
                                                - required:
                                                    - server
                                              properties:
                                                none:
                                                  type: object
                                                  description: Use TLS but don't verify certificates
                                                server:
                                                  type: object
                                                  required:
                                                    - caCert
                                                  properties:
                                                    caCert:
                                                      type: object
                                                      oneOf:
                                                        - required:
                                                            - webPki
                                                        - required:
                                                            - secretClass
                                                      properties:
                                                        webPki:
                                                          type: object
                                                          description: Use TLS and the ca certificates trusted by the common web browsers
                                                            to verify the
                                                            server. This can be
                                                            useful when you e.g.
                                                            use public AWS S3 or
                                                            other public
                                                            available services.
                                                        secretClass:
                                                          type: string
                                                          description: Name of the SecretClass which will provide the ca cert. Note that a
                                                            SecretClass does not
                                                            need to have a key
                                                            but can also work
                                                            with just a ca cert.
                                                            So if you got
                                                            provided with a ca
                                                            cert but don't have
                                                            access to the key
                                                            you can still use
                                                            this method.
                                                      description: Ca cert to verify the server
                                                  description: Use TLS and ca certificate to verify the server
                                              description: The verification method used to verify the certificates of the
                                                server and/or the client
                                          description: If you want to use TLS when talking to S3 you can enable TLS
                                            encrypted communication with this
                                            setting.
                                        host:
                                          type: string
                                          nullable: true
                                          description: Hostname of the S3 server without any protocol or port
                                        port:
                                          type: integer
                                          format: uint16
                                          minimum: 0
                                          nullable: true
                                          description: Port the S3 server listens on. If not specified the products will
                                            determine the port to use.
                                        accessStyle:
                                          enum:
                                            - Path
                                            - VirtualHosted
                                          type: string
                                          nullable: true
                                          description: Which access style to use. Defaults to virtual hosted-style as most
                                            of the data products out there. Have
                                            a look at the official documentation
                                            on
                                            <https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html>
                                        credentials:
                                          type: object
                                          nullable: true
                                          required:
                                            - secretClass
                                          properties:
                                            scope:
                                              type: object
                                              nullable: true
                                              properties:
                                                pod:
                                                  type: boolean
                                                  default: false
                                                node:
                                                  type: boolean
                                                  default: false
                                                services:
                                                  type: array
                                                  items:
                                                    type: string
                                                  default: []
                                              description: "[Scope](https://docs.stackable.tech/secret-operator/scope.html) of
                                                the
                                                [SecretClass](https://docs.stac\
                                                kable.tech/secret-operator/secr\
                                                etclass.html)"
                                            secretClass:
                                              type: string
                                              description: "[SecretClass](https://docs.stackable.tech/secret-operator/secretc\
                                                lass.html) containing the LDAP
                                                bind credentials"
                                          description: If the S3 uses authentication you have to specify you S3
                                            credentials. In the most cases a
                                            SecretClass providing `accessKey`
                                            and `secretKey` is sufficient.
                                      description: S3 connection definition as CRD.
                                    reference:
                                      type: string
                                  description: Operators are expected to define fields for this type in order to
                                    work with S3 connections.
                              description: S3 bucket specification containing only the bucket name and an
                                inlined or referenced connection specification.
                            reference:
                              type: string
                          description: Operators are expected to define fields for this type in order to
                            work with S3 buckets.
                        prefix:
                          type: string
                vectorAggregatorConfigMapName:
                  type: string
                  nullable: true
                  description: Name of the Vector aggregator discovery ConfigMap. It must contain
                    the key `ADDRESS` with the address of the Vector aggregator.
          description: Auto-generated derived type for SparkHistoryServerSpec via
            `CustomResource`
      served: true
      storage: true
      subresources: {}
      additionalPrinterColumns: []
metadata:
  name: sparkhistoryservers.spark.stackable.tech
  annotations:
    helm.sh/resource-policy: keep
apiVersion: apiextensions.k8s.io/v1
