kind: CustomResourceDefinition
spec:
  group: hive.stackable.tech
  names:
    kind: HiveCluster
    plural: hiveclusters
    singular: hivecluster
    categories: []
    shortNames:
      - hive
  scope: Namespaced
  versions:
    - name: v1alpha1
      schema:
        openAPIV3Schema:
          type: object
          title: HiveCluster
          required:
            - spec
          properties:
            spec:
              type: object
              required:
                - clusterConfig
                - image
              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
                  description: The Hive metastore image to use
                stopped:
                  type: boolean
                  nullable: true
                  description: Emergency stop button, if `true` then all pods are stopped without
                    affecting configuration (as setting `replicas` to `0` would)
                metastore:
                  type: object
                  nullable: true
                  required:
                    - roleGroups
                  properties:
                    config:
                      type: object
                      default: {}
                      properties:
                        resources:
                          type: object
                          nullable: true
                          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
                        warehouseDir:
                          type: string
                          nullable: true
                          description: The location of default database for the Hive warehouse. Maps to
                            the `hive.metastore.warehouse.dir` setting.
                    roleGroups:
                      type: object
                      additionalProperties:
                        type: object
                        properties:
                          config:
                            type: object
                            default: {}
                            properties:
                              resources:
                                type: object
                                nullable: true
                                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
                              warehouseDir:
                                type: string
                                nullable: true
                                description: The location of default database for the Hive warehouse. Maps to
                                  the `hive.metastore.warehouse.dir` setting.
                          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
                clusterConfig:
                  type: object
                  required:
                    - database
                  properties:
                    s3:
                      type: object
                      oneOf:
                        - required:
                            - inline
                        - required:
                            - reference
                      nullable: true
                      properties:
                        inline:
                          type: object
                          properties:
                            tls:
                              type: object
                              nullable: true
                              required:
                                - verification
                              properties:
                                verification:
                                  type: object
                                  oneOf:
                                    - required:
                                        - none
                                    - required:
                                        - server
                                  properties:
                                    none:
                                      type: object
                                      description: Use TLS but don't verify certificates
                                    server:
                                      type: object
                                      required:
                                        - caCert
                                      properties:
                                        caCert:
                                          type: object
                                          oneOf:
                                            - required:
                                                - webPki
                                            - required:
                                                - secretClass
                                          properties:
                                            webPki:
                                              type: object
                                              description: Use TLS and the ca certificates trusted by the common web browsers
                                                to verify the server. This can
                                                be useful when you e.g. use
                                                public AWS S3 or other public
                                                available services.
                                            secretClass:
                                              type: string
                                              description: Name of the SecretClass which will provide the ca cert. Note that a
                                                SecretClass does not need to
                                                have a key but can also work
                                                with just a ca cert. So if you
                                                got provided with a ca cert but
                                                don't have access to the key you
                                                can still use this method.
                                          description: Ca cert to verify the server
                                      description: Use TLS and ca certificate to verify the server
                                  description: The verification method used to verify the certificates of the
                                    server and/or the client
                              description: If you want to use TLS when talking to S3 you can enable TLS
                                encrypted communication with this setting.
                            host:
                              type: string
                              nullable: true
                              description: Hostname of the S3 server without any protocol or port
                            port:
                              type: integer
                              format: uint16
                              minimum: 0
                              nullable: true
                              description: Port the S3 server listens on. If not specified the products will
                                determine the port to use.
                            accessStyle:
                              enum:
                                - Path
                                - VirtualHosted
                              type: string
                              nullable: true
                              description: Which access style to use. Defaults to virtual hosted-style as most
                                of the data products out there. Have a look at
                                the official documentation on
                                <https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html>
                            credentials:
                              type: object
                              nullable: true
                              required:
                                - secretClass
                              properties:
                                scope:
                                  type: object
                                  nullable: true
                                  properties:
                                    pod:
                                      type: boolean
                                      default: false
                                    node:
                                      type: boolean
                                      default: false
                                    services:
                                      type: array
                                      items:
                                        type: string
                                      default: []
                                  description: "[Scope](https://docs.stackable.tech/secret-operator/scope.html) of
                                    the
                                    [SecretClass](https://docs.stackable.tech/s\
                                    ecret-operator/secretclass.html)"
                                secretClass:
                                  type: string
                                  description: "[SecretClass](https://docs.stackable.tech/secret-operator/secretc\
                                    lass.html) containing the LDAP bind
                                    credentials"
                              description: If the S3 uses authentication you have to specify you S3
                                credentials. In the most cases a SecretClass
                                providing `accessKey` and `secretKey` is
                                sufficient.
                          description: S3 connection definition as CRD.
                        reference:
                          type: string
                      description: S3 connection specification
                    hdfs:
                      type: object
                      nullable: true
                      required:
                        - configMap
                      properties:
                        configMap:
                          type: string
                          description: Name of the discovery-configmap providing information about the
                            HDFS cluster
                      description: HDFS connection specification
                    database:
                      type: object
                      required:
                        - connString
                        - dbType
                        - password
                        - user
                      properties:
                        user:
                          type: string
                        dbType:
                          enum:
                            - derby
                            - mysql
                            - postgres
                            - oracle
                            - mssql
                          type: string
                        password:
                          type: string
                        connString:
                          type: string
                      description: Database connection specification
                    serviceType:
                      enum:
                        - NodePort
                        - ClusterIP
                      type: string
                      nullable: true
                      description: Specify the type of the created kubernetes service. This attribute
                        will be removed in a future release when
                        listener-operator is finished. Use with caution.
                  description: General Hive metastore cluster settings
            status:
              type: object
              nullable: true
              properties:
                discoveryHash:
                  type: string
                  nullable: true
                  description: An opaque value that changes every time a discovery detail does
          description: Auto-generated derived type for HiveClusterSpec via `CustomResource`
      served: true
      storage: true
      subresources:
        status: {}
      additionalPrinterColumns: []
metadata:
  name: hiveclusters.hive.stackable.tech
  annotations:
    helm.sh/resource-policy: keep
apiVersion: apiextensions.k8s.io/v1
