kind: CustomResourceDefinition
spec:
  group: hdfs.stackable.tech
  names:
    kind: HdfsCluster
    plural: hdfsclusters
    singular: hdfscluster
    categories: []
    shortNames:
      - hdfs
  scope: Namespaced
  versions:
    - name: v1alpha1
      schema:
        openAPIV3Schema:
          type: object
          title: HdfsCluster
          required:
            - spec
          properties:
            spec:
              type: object
              required:
                - image
                - zookeeperConfigMapName
              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
                dataNodes:
                  type: object
                  nullable: true
                  required:
                    - roleGroups
                  properties:
                    config:
                      type: object
                      default: {}
                      properties:
                        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
                        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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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
                              additionalProperties:
                                type: object
                                properties:
                                  count:
                                    type: integer
                                    format: uint16
                                    default: 1
                                    minimum: 0
                                    nullable: true
                                  capacity:
                                    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:
                                        a. No precision is lost
                                        b. No fractional digits will be emitted
                                        c. 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.
                                  selectors:
                                    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.
                                  storageClass:
                                    type: string
                                    nullable: true
                                  hdfsStorageType:
                                    enum:
                                      - Archive
                                      - Disk
                                      - SSD
                                      - RAMDisk
                                    type: string
                                    nullable: true
                    roleGroups:
                      type: object
                      additionalProperties:
                        type: object
                        properties:
                          config:
                            type: object
                            default: {}
                            properties:
                              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
                              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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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
                                    additionalProperties:
                                      type: object
                                      properties:
                                        count:
                                          type: integer
                                          format: uint16
                                          default: 1
                                          minimum: 0
                                          nullable: true
                                        capacity:
                                          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:
                                              a. No precision is lost
                                              b. No fractional digits will be emitted
                                              c. 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.
                                        selectors:
                                          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.
                                        storageClass:
                                          type: string
                                          nullable: true
                                        hdfsStorageType:
                                          enum:
                                            - Archive
                                            - Disk
                                            - SSD
                                            - RAMDisk
                                          type: string
                                          nullable: true
                          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
                nameNodes:
                  type: object
                  nullable: true
                  required:
                    - roleGroups
                  properties:
                    config:
                      type: object
                      default: {}
                      properties:
                        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
                        resources:
                          type: object
                          default:
                            cpu:
                              max: null
                              min: null
                            memory:
                              limit: null
                              runtimeLimits: {}
                            storage:
                              data:
                                capacity: null
                          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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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
                              properties:
                                data:
                                  type: object
                                  default:
                                    capacity: null
                                  properties:
                                    capacity:
                                      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:
                                          a. No precision is lost
                                          b. No fractional digits will be emitted
                                          c. 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.
                                    selectors:
                                      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.
                                    storageClass:
                                      type: string
                                      nullable: true
                    roleGroups:
                      type: object
                      additionalProperties:
                        type: object
                        properties:
                          config:
                            type: object
                            default: {}
                            properties:
                              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
                              resources:
                                type: object
                                default:
                                  cpu:
                                    max: null
                                    min: null
                                  memory:
                                    limit: null
                                    runtimeLimits: {}
                                  storage:
                                    data:
                                      capacity: null
                                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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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
                                    properties:
                                      data:
                                        type: object
                                        default:
                                          capacity: null
                                        properties:
                                          capacity:
                                            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:
                                                a. No precision is lost
                                                b. No fractional digits will be emitted
                                                c. 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.
                                          selectors:
                                            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.
                                          storageClass:
                                            type: string
                                            nullable: true
                          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
                autoFormatFs:
                  type: boolean
                  nullable: true
                journalNodes:
                  type: object
                  nullable: true
                  required:
                    - roleGroups
                  properties:
                    config:
                      type: object
                      default: {}
                      properties:
                        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
                        resources:
                          type: object
                          default:
                            cpu:
                              max: null
                              min: null
                            memory:
                              limit: null
                              runtimeLimits: {}
                            storage:
                              data:
                                capacity: null
                          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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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:
                                      a. No precision is lost
                                      b. No fractional digits will be emitted
                                      c. 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
                              properties:
                                data:
                                  type: object
                                  default:
                                    capacity: null
                                  properties:
                                    capacity:
                                      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:
                                          a. No precision is lost
                                          b. No fractional digits will be emitted
                                          c. 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.
                                    selectors:
                                      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.
                                    storageClass:
                                      type: string
                                      nullable: true
                    roleGroups:
                      type: object
                      additionalProperties:
                        type: object
                        properties:
                          config:
                            type: object
                            default: {}
                            properties:
                              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
                              resources:
                                type: object
                                default:
                                  cpu:
                                    max: null
                                    min: null
                                  memory:
                                    limit: null
                                    runtimeLimits: {}
                                  storage:
                                    data:
                                      capacity: null
                                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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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:
                                            a. No precision is lost
                                            b. No fractional digits will be emitted
                                            c. 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
                                    properties:
                                      data:
                                        type: object
                                        default:
                                          capacity: null
                                        properties:
                                          capacity:
                                            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:
                                                a. No precision is lost
                                                b. No fractional digits will be emitted
                                                c. 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.
                                          selectors:
                                            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.
                                          storageClass:
                                            type: string
                                            nullable: true
                          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
                dfsReplication:
                  type: integer
                  format: uint8
                  minimum: 0
                  nullable: true
                zookeeperConfigMapName:
                  type: string
                  description: Name of the ZooKeeper discovery config map.
                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 HdfsClusterSpec via `CustomResource`
      served: true
      storage: true
      subresources: {}
      additionalPrinterColumns: []
metadata:
  name: hdfsclusters.hdfs.stackable.tech
  annotations:
    helm.sh/resource-policy: keep
apiVersion: apiextensions.k8s.io/v1
