kind: CustomResourceDefinition
spec:
  group: nifi.stackable.tech
  names:
    kind: NifiCluster
    plural: nificlusters
    singular: nificluster
    categories: []
    shortNames:
      - nifi
  scope: Namespaced
  versions:
    - name: v1alpha1
      schema:
        openAPIV3Schema:
          type: object
          title: NifiCluster
          required:
            - spec
          properties:
            spec:
              type: object
              required:
                - clusterConfig
                - image
              properties:
                image:
                  type: object
                  anyOf:
                    - required:
                        - custom
                        - productVersion
                    - required:
                        - productVersion
                  properties:
                    repo:
                      type: string
                      nullable: true
                      description: Name of the docker repo, e.g. `oci.stackable.tech/sdp`
                    custom:
                      type: string
                      description: Overwrite the docker image. Specify the full docker image name,
                        e.g.
                        `oci.stackable.tech/sdp/superset:1.4.1-stackable2.1.0`
                    pullPolicy:
                      enum:
                        - IfNotPresent
                        - Always
                        - Never
                      type: string
                      default: Always
                      description: "[Pull
                        policy](https://kubernetes.io/docs/concepts/containers/image\
                        s/#image-pull-policy) used when pulling the image."
                    pullSecrets:
                      type: array
                      items:
                        type: object
                        required:
                          - name
                        properties:
                          name:
                            type: string
                            description: "Name of the referent. This field is effectively required, but due
                              to backwards compatibility is allowed to be empty.
                              Instances of this type with an empty value here
                              are almost certainly wrong. 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
                      nullable: true
                      description: Stackable version of the product, e.g. `23.4`, `23.4.1` or
                        `0.0.0-dev`. If not specified, the operator will use its
                        own version, e.g. `23.4.1`. When using a nightly
                        operator or a pr version, it will use the nightly
                        `0.0.0-dev` image.
                  description: |-
                    Specify which image to use, the easiest way is to only configure the `productVersion`. You can also configure a custom image registry to pull from, as well as completely custom images.

                    Consult the [Product image selection documentation](https://docs.stackable.tech/home/25.3/concepts/product_image_selection) for details.
                nodes:
                  type: object
                  nullable: true
                  required:
                    - roleGroups
                  properties:
                    config:
                      type: object
                      default: {}
                      properties:
                        logging:
                          type: object
                          default:
                            containers: {}
                            enableVectorAgent: null
                          properties:
                            containers:
                              type: object
                              description: Log configuration per container.
                              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: The log level threshold. Log events with a lower log level are
                                          discarded.
                                    description: Configuration for the file appender
                                  custom:
                                    type: object
                                    properties:
                                      configMap:
                                        type: string
                                        nullable: true
                                        description: ConfigMap containing the log configuration files
                                    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: The log level threshold. Log events with a lower log level are
                                          discarded.
                                    description: Configuration for the console appender
                                  loggers:
                                    type: object
                                    default: {}
                                    description: Configuration per logger
                                    additionalProperties:
                                      type: object
                                      properties:
                                        level:
                                          enum:
                                            - TRACE
                                            - DEBUG
                                            - INFO
                                            - WARN
                                            - ERROR
                                            - FATAL
                                            - NONE
                                          type: string
                                          nullable: true
                                          description: The log level threshold. Log events with a lower log level are
                                            discarded.
                                      description: Configuration of a logger
                                description: Log configuration of the container
                            enableVectorAgent:
                              type: boolean
                              nullable: true
                              description: Wether or not to deploy a container with the Vector log agent.
                          description: Logging configuration, learn more in the [logging concept
                            documentation](https://docs.stackable.tech/home/25.3/concepts/logging).
                        affinity:
                          type: object
                          default:
                            podAffinity: null
                            nodeAffinity: null
                            nodeSelector: null
                            podAntiAffinity: null
                          properties:
                            podAffinity:
                              type: object
                              nullable: true
                              description: Same as the `spec.affinity.podAffinity` field on the Pod, see the
                                [Kubernetes
                                docs](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node)
                              x-kubernetes-preserve-unknown-fields: true
                            nodeAffinity:
                              type: object
                              nullable: true
                              description: Same as the `spec.affinity.nodeAffinity` field on the Pod, see the
                                [Kubernetes
                                docs](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node)
                              x-kubernetes-preserve-unknown-fields: true
                            nodeSelector:
                              type: object
                              nullable: true
                              description: Simple key-value pairs forming a nodeSelector, see the [Kubernetes
                                docs](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node)
                              additionalProperties:
                                type: string
                            podAntiAffinity:
                              type: object
                              nullable: true
                              description: Same as the `spec.affinity.podAntiAffinity` field on the Pod, see
                                the [Kubernetes
                                docs](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node)
                              x-kubernetes-preserve-unknown-fields: true
                          description: These configuration settings control [Pod
                            placement](https://docs.stackable.tech/home/25.3/concepts/operations/pod_placement).
                        resources:
                          type: object
                          default:
                            cpu:
                              max: null
                              min: null
                            memory:
                              limit: null
                              runtimeLimits: {}
                            storage:
                              stateRepo:
                                capacity: null
                              contentRepo:
                                capacity: null
                              databaseRepo:
                                capacity: null
                              flowfileRepo:
                                capacity: null
                              provenanceRepo:
                                capacity: null
                          properties:
                            cpu:
                              type: object
                              default:
                                max: null
                                min: null
                              properties:
                                max:
                                  type: string
                                  nullable: true
                                  description: The maximum amount of CPU cores that can be requested by Pods.
                                    Equivalent to the `limit` for Pod resource
                                    configuration. Cores are specified either as
                                    a decimal point number or as milli units.
                                    For example:`1.5` will be 1.5 cores, also
                                    written as `1500m`.
                                min:
                                  type: string
                                  nullable: true
                                  description: The minimal amount of CPU cores that Pods need to run. Equivalent
                                    to the `request` for Pod resource
                                    configuration. Cores are specified either as
                                    a decimal point number or as milli units.
                                    For example:`1.5` will be 1.5 cores, also
                                    written as `1500m`.
                            memory:
                              type: object
                              properties:
                                limit:
                                  type: string
                                  nullable: true
                                  description: "The maximum amount of memory that should be available to the Pod.
                                    Specified as a byte
                                    [Quantity](https://kubernetes.io/docs/refer\
                                    ence/kubernetes-api/common-definitions/quan\
                                    tity/), which means these suffixes are
                                    supported: E, P, T, G, M, k. You can also
                                    use the power-of-two equivalents: Ei, Pi,
                                    Ti, Gi, Mi, Ki. For example, the following
                                    represent roughly the same value:
                                    `128974848, 129e6, 129M,  128974848000m,
                                    123Mi`"
                                runtimeLimits:
                                  type: object
                                  description: Additional options that can be specified.
                            storage:
                              type: object
                              properties:
                                stateRepo:
                                  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:


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


                                        The sign will be omitted unless the
                                        number is negative.


                                        Examples:


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


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


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


                                        This format is intended to make it
                                        difficult to use these numbers without
                                        writing some sort of special handling
                                        code in the hopes that that will cause
                                        implementors to also use a fixed point
                                        implementation.
                                    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
                                  description: "Default size: 1GB"
                                contentRepo:
                                  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:


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


                                        The sign will be omitted unless the
                                        number is negative.


                                        Examples:


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


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


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


                                        This format is intended to make it
                                        difficult to use these numbers without
                                        writing some sort of special handling
                                        code in the hopes that that will cause
                                        implementors to also use a fixed point
                                        implementation.
                                    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
                                  description: |-
                                    [The Content Repository](https://nifi.apache.org/docs/nifi-docs/html/nifi-in-depth.html#content-repository) is simply a place in local storage where the content of all FlowFiles exists and it is typically the largest of the Repositories.

                                    Default size: 4GB
                                databaseRepo:
                                  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:


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


                                        The sign will be omitted unless the
                                        number is negative.


                                        Examples:


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


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


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


                                        This format is intended to make it
                                        difficult to use these numbers without
                                        writing some sort of special handling
                                        code in the hopes that that will cause
                                        implementors to also use a fixed point
                                        implementation.
                                    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
                                  description: "Default size: 1GB"
                                flowfileRepo:
                                  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:


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


                                        The sign will be omitted unless the
                                        number is negative.


                                        Examples:


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


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


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


                                        This format is intended to make it
                                        difficult to use these numbers without
                                        writing some sort of special handling
                                        code in the hopes that that will cause
                                        implementors to also use a fixed point
                                        implementation.
                                    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
                                  description: |-
                                    [The FlowFile Repository](https://nifi.apache.org/docs/nifi-docs/html/nifi-in-depth.html#flowfile-repository) is where NiFi keeps track of the state and metadata of FlowFiles as they traverse the data flow. The repository ensures durability, reliability, and recoverability of data in case of system failures or interruptions.

                                    Default size: 1GB
                                provenanceRepo:
                                  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:


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


                                        The sign will be omitted unless the
                                        number is negative.


                                        Examples:


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


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


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


                                        This format is intended to make it
                                        difficult to use these numbers without
                                        writing some sort of special handling
                                        code in the hopes that that will cause
                                        implementors to also use a fixed point
                                        implementation.
                                    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
                                  description: |-
                                    [The Provenance Repository](https://nifi.apache.org/docs/nifi-docs/html/nifi-in-depth.html#provenance-repository) is where the history of each FlowFile is stored. This history is used to provide the Data Lineage (also known as the Chain of Custody) of each piece of data.

                                    Default size: 2GB
                          description: Resource usage is configured here, this includes CPU usage, memory
                            usage and disk storage usage. The default CPU
                            request and limit are 500m and 2000m respectively.
                            The default memory limit is 4GB.
                        gracefulShutdownTimeout:
                          type: string
                          nullable: true
                          description: Time period Pods have to gracefully shut down, e.g. `30m`, `1h` or
                            `2d`. Consult the operator documentation for
                            details.
                        requestedSecretLifetime:
                          type: string
                          nullable: true
                          description: Request secret (currently only autoTls certificates) lifetime from
                            the secret operator, e.g. `7d`, or `30d`. Please
                            note that this can be shortened by the
                            `maxCertificateLifetime` setting on the SecretClass
                            issuing the TLS certificate.
                    roleConfig:
                      type: object
                      default:
                        podDisruptionBudget:
                          enabled: true
                          maxUnavailable: null
                      properties:
                        podDisruptionBudget:
                          type: object
                          default:
                            enabled: true
                            maxUnavailable: null
                          properties:
                            enabled:
                              type: boolean
                              default: true
                              description: Whether a PodDisruptionBudget should be written out for this role.
                                Disabling this enables you to specify your own -
                                custom - one. Defaults to true.
                            maxUnavailable:
                              type: integer
                              format: uint16
                              minimum: 0
                              nullable: true
                              description: The number of Pods that are allowed to be down because of voluntary
                                disruptions. If you don't explicitly set this,
                                the operator will use a sane default based upon
                                knowledge about the individual product.
                          description: |-
                            This struct is used to configure:

                            1. If PodDisruptionBudgets are created by the operator 2. The allowed number of Pods to be unavailable (`maxUnavailable`)

                            Learn more in the [allowed Pod disruptions documentation](https://docs.stackable.tech/home/25.3/concepts/operations/pod_disruptions).
                      description: This is a product-agnostic RoleConfig, which is sufficient for most
                        of the products.
                    roleGroups:
                      type: object
                      additionalProperties:
                        type: object
                        properties:
                          config:
                            type: object
                            default: {}
                            properties:
                              logging:
                                type: object
                                default:
                                  containers: {}
                                  enableVectorAgent: null
                                properties:
                                  containers:
                                    type: object
                                    description: Log configuration per container.
                                    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: The log level threshold. Log events with a lower log level are
                                                discarded.
                                          description: Configuration for the file appender
                                        custom:
                                          type: object
                                          properties:
                                            configMap:
                                              type: string
                                              nullable: true
                                              description: ConfigMap containing the log configuration files
                                          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: The log level threshold. Log events with a lower log level are
                                                discarded.
                                          description: Configuration for the console appender
                                        loggers:
                                          type: object
                                          default: {}
                                          description: Configuration per logger
                                          additionalProperties:
                                            type: object
                                            properties:
                                              level:
                                                enum:
                                                  - TRACE
                                                  - DEBUG
                                                  - INFO
                                                  - WARN
                                                  - ERROR
                                                  - FATAL
                                                  - NONE
                                                type: string
                                                nullable: true
                                                description: The log level threshold. Log events with a lower log level are
                                                  discarded.
                                            description: Configuration of a logger
                                      description: Log configuration of the container
                                  enableVectorAgent:
                                    type: boolean
                                    nullable: true
                                    description: Wether or not to deploy a container with the Vector log agent.
                                description: Logging configuration, learn more in the [logging concept
                                  documentation](https://docs.stackable.tech/home/25.3/concepts/logging).
                              affinity:
                                type: object
                                default:
                                  podAffinity: null
                                  nodeAffinity: null
                                  nodeSelector: null
                                  podAntiAffinity: null
                                properties:
                                  podAffinity:
                                    type: object
                                    nullable: true
                                    description: Same as the `spec.affinity.podAffinity` field on the Pod, see the
                                      [Kubernetes
                                      docs](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node)
                                    x-kubernetes-preserve-unknown-fields: true
                                  nodeAffinity:
                                    type: object
                                    nullable: true
                                    description: Same as the `spec.affinity.nodeAffinity` field on the Pod, see the
                                      [Kubernetes
                                      docs](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node)
                                    x-kubernetes-preserve-unknown-fields: true
                                  nodeSelector:
                                    type: object
                                    nullable: true
                                    description: Simple key-value pairs forming a nodeSelector, see the [Kubernetes
                                      docs](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node)
                                    additionalProperties:
                                      type: string
                                  podAntiAffinity:
                                    type: object
                                    nullable: true
                                    description: Same as the `spec.affinity.podAntiAffinity` field on the Pod, see
                                      the [Kubernetes
                                      docs](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node)
                                    x-kubernetes-preserve-unknown-fields: true
                                description: These configuration settings control [Pod
                                  placement](https://docs.stackable.tech/home/25.3/concepts/operations/pod_placement).
                              resources:
                                type: object
                                default:
                                  cpu:
                                    max: null
                                    min: null
                                  memory:
                                    limit: null
                                    runtimeLimits: {}
                                  storage:
                                    stateRepo:
                                      capacity: null
                                    contentRepo:
                                      capacity: null
                                    databaseRepo:
                                      capacity: null
                                    flowfileRepo:
                                      capacity: null
                                    provenanceRepo:
                                      capacity: null
                                properties:
                                  cpu:
                                    type: object
                                    default:
                                      max: null
                                      min: null
                                    properties:
                                      max:
                                        type: string
                                        nullable: true
                                        description: The maximum amount of CPU cores that can be requested by Pods.
                                          Equivalent to the `limit` for Pod
                                          resource configuration. Cores are
                                          specified either as a decimal point
                                          number or as milli units. For
                                          example:`1.5` will be 1.5 cores, also
                                          written as `1500m`.
                                      min:
                                        type: string
                                        nullable: true
                                        description: The minimal amount of CPU cores that Pods need to run. Equivalent
                                          to the `request` for Pod resource
                                          configuration. Cores are specified
                                          either as a decimal point number or as
                                          milli units. For example:`1.5` will be
                                          1.5 cores, also written as `1500m`.
                                  memory:
                                    type: object
                                    properties:
                                      limit:
                                        type: string
                                        nullable: true
                                        description: "The maximum amount of memory that should be available to the Pod.
                                          Specified as a byte
                                          [Quantity](https://kubernetes.io/docs\
                                          /reference/kubernetes-api/common-defi\
                                          nitions/quantity/), which means these
                                          suffixes are supported: E, P, T, G, M,
                                          k. You can also use the power-of-two
                                          equivalents: Ei, Pi, Ti, Gi, Mi, Ki.
                                          For example, the following represent
                                          roughly the same value: `128974848,
                                          129e6, 129M,  128974848000m, 123Mi`"
                                      runtimeLimits:
                                        type: object
                                        description: Additional options that can be specified.
                                  storage:
                                    type: object
                                    properties:
                                      stateRepo:
                                        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:


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


                                              The sign will be omitted unless
                                              the number is negative.


                                              Examples:


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


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


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


                                              This format is intended to make it
                                              difficult to use these numbers
                                              without writing some sort of
                                              special handling code in the hopes
                                              that that will cause implementors
                                              to also use a fixed point
                                              implementation.
                                          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
                                        description: "Default size: 1GB"
                                      contentRepo:
                                        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:


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


                                              The sign will be omitted unless
                                              the number is negative.


                                              Examples:


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


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


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


                                              This format is intended to make it
                                              difficult to use these numbers
                                              without writing some sort of
                                              special handling code in the hopes
                                              that that will cause implementors
                                              to also use a fixed point
                                              implementation.
                                          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
                                        description: |-
                                          [The Content Repository](https://nifi.apache.org/docs/nifi-docs/html/nifi-in-depth.html#content-repository) is simply a place in local storage where the content of all FlowFiles exists and it is typically the largest of the Repositories.

                                          Default size: 4GB
                                      databaseRepo:
                                        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:


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


                                              The sign will be omitted unless
                                              the number is negative.


                                              Examples:


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


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


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


                                              This format is intended to make it
                                              difficult to use these numbers
                                              without writing some sort of
                                              special handling code in the hopes
                                              that that will cause implementors
                                              to also use a fixed point
                                              implementation.
                                          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
                                        description: "Default size: 1GB"
                                      flowfileRepo:
                                        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:


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


                                              The sign will be omitted unless
                                              the number is negative.


                                              Examples:


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


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


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


                                              This format is intended to make it
                                              difficult to use these numbers
                                              without writing some sort of
                                              special handling code in the hopes
                                              that that will cause implementors
                                              to also use a fixed point
                                              implementation.
                                          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
                                        description: |-
                                          [The FlowFile Repository](https://nifi.apache.org/docs/nifi-docs/html/nifi-in-depth.html#flowfile-repository) is where NiFi keeps track of the state and metadata of FlowFiles as they traverse the data flow. The repository ensures durability, reliability, and recoverability of data in case of system failures or interruptions.

                                          Default size: 1GB
                                      provenanceRepo:
                                        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:


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


                                              The sign will be omitted unless
                                              the number is negative.


                                              Examples:


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


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


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


                                              This format is intended to make it
                                              difficult to use these numbers
                                              without writing some sort of
                                              special handling code in the hopes
                                              that that will cause implementors
                                              to also use a fixed point
                                              implementation.
                                          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
                                        description: |-
                                          [The Provenance Repository](https://nifi.apache.org/docs/nifi-docs/html/nifi-in-depth.html#provenance-repository) is where the history of each FlowFile is stored. This history is used to provide the Data Lineage (also known as the Chain of Custody) of each piece of data.

                                          Default size: 2GB
                                description: Resource usage is configured here, this includes CPU usage, memory
                                  usage and disk storage usage. The default CPU
                                  request and limit are 500m and 2000m
                                  respectively. The default memory limit is 4GB.
                              gracefulShutdownTimeout:
                                type: string
                                nullable: true
                                description: Time period Pods have to gracefully shut down, e.g. `30m`, `1h` or
                                  `2d`. Consult the operator documentation for
                                  details.
                              requestedSecretLifetime:
                                type: string
                                nullable: true
                                description: Request secret (currently only autoTls certificates) lifetime from
                                  the secret operator, e.g. `7d`, or `30d`.
                                  Please note that this can be shortened by the
                                  `maxCertificateLifetime` setting on the
                                  SecretClass issuing the TLS certificate.
                          replicas:
                            type: integer
                            format: uint16
                            minimum: 0
                            nullable: true
                          cliOverrides:
                            type: object
                            default: {}
                            additionalProperties:
                              type: string
                          envOverrides:
                            type: object
                            default: {}
                            description: "`envOverrides` configure environment variables to be set in the
                              Pods. It is a map from strings to strings -
                              environment variables and the value to set. Read
                              the [environment variable overrides
                              documentation](https://docs.stackable.tech/home/2\
                              5.3/concepts/overrides#env-overrides) for more
                              information and consult the operator specific
                              usage guide to find out about the product specific
                              environment variables that are available."
                            additionalProperties:
                              type: string
                          podOverrides:
                            type: object
                            default: {}
                            description: In the `podOverrides` property you can define a
                              [PodTemplateSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#podtemplatespec-v1-core)
                              to override any property that can be set on a
                              Kubernetes Pod. Read the [Pod overrides
                              documentation](https://docs.stackable.tech/home/25.3/concepts/overrides#pod-overrides)
                              for more information.
                            x-kubernetes-preserve-unknown-fields: true
                          configOverrides:
                            type: object
                            default: {}
                            description: The `configOverrides` can be used to configure properties in
                              product config files that are not exposed in the
                              CRD. Read the [config overrides
                              documentation](https://docs.stackable.tech/home/25.3/concepts/overrides#config-overrides)
                              and consult the operator specific usage guide
                              documentation for details on the available config
                              files and settings for the specific product.
                            additionalProperties:
                              type: object
                              additionalProperties:
                                type: string
                          jvmArgumentOverrides:
                            type: object
                            default:
                              add: []
                              remove: []
                              removeRegex: []
                            properties:
                              add:
                                type: array
                                items:
                                  type: string
                                default: []
                                description: JVM arguments to be added
                              remove:
                                type: array
                                items:
                                  type: string
                                default: []
                                description: JVM arguments to be removed by exact match
                              removeRegex:
                                type: array
                                items:
                                  type: string
                                default: []
                                description: JVM arguments matching any of this regexes will be removed
                            description: Allows overriding JVM arguments. Please read on the [JVM argument
                              overrides
                              documentation](https://docs.stackable.tech/home/25.3/concepts/overrides#jvm-argument-overrides)
                              for details on the usage.
                    cliOverrides:
                      type: object
                      default: {}
                      additionalProperties:
                        type: string
                    envOverrides:
                      type: object
                      default: {}
                      description: "`envOverrides` configure environment variables to be set in the
                        Pods. It is a map from strings to strings - environment
                        variables and the value to set. Read the [environment
                        variable overrides
                        documentation](https://docs.stackable.tech/home/25.3/co\
                        ncepts/overrides#env-overrides) for more information and
                        consult the operator specific usage guide to find out
                        about the product specific environment variables that
                        are available."
                      additionalProperties:
                        type: string
                    podOverrides:
                      type: object
                      default: {}
                      description: In the `podOverrides` property you can define a
                        [PodTemplateSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#podtemplatespec-v1-core)
                        to override any property that can be set on a Kubernetes
                        Pod. Read the [Pod overrides
                        documentation](https://docs.stackable.tech/home/25.3/concepts/overrides#pod-overrides)
                        for more information.
                      x-kubernetes-preserve-unknown-fields: true
                    configOverrides:
                      type: object
                      default: {}
                      description: The `configOverrides` can be used to configure properties in
                        product config files that are not exposed in the CRD.
                        Read the [config overrides
                        documentation](https://docs.stackable.tech/home/25.3/concepts/overrides#config-overrides)
                        and consult the operator specific usage guide
                        documentation for details on the available config files
                        and settings for the specific product.
                      additionalProperties:
                        type: object
                        additionalProperties:
                          type: string
                    jvmArgumentOverrides:
                      type: object
                      default:
                        add: []
                        remove: []
                        removeRegex: []
                      properties:
                        add:
                          type: array
                          items:
                            type: string
                          default: []
                          description: JVM arguments to be added
                        remove:
                          type: array
                          items:
                            type: string
                          default: []
                          description: JVM arguments to be removed by exact match
                        removeRegex:
                          type: array
                          items:
                            type: string
                          default: []
                          description: JVM arguments matching any of this regexes will be removed
                      description: Allows overriding JVM arguments. Please read on the [JVM argument
                        overrides
                        documentation](https://docs.stackable.tech/home/25.3/concepts/overrides#jvm-argument-overrides)
                        for details on the usage.
                  description: This struct represents a role - e.g. HDFS datanodes or Trino
                    workers. It has a key-value-map containing all the
                    roleGroups that are part of this role. Additionally, there
                    is a `config`, which is configurable at the role *and*
                    roleGroup level. Everything at roleGroup level is merged on
                    top of what is configured on role level. There is also a
                    second form of config, which can only be configured at role
                    level, the `roleConfig`. You can learn more about this in
                    the [Roles and role group concept
                    documentation](https://docs.stackable.tech/home/25.3/concepts/roles-and-role-groups).
                clusterConfig:
                  type: object
                  required:
                    - authentication
                    - sensitiveProperties
                    - zookeeperConfigMapName
                  properties:
                    tls:
                      type: object
                      default:
                        serverSecretClass: tls
                      properties:
                        serverSecretClass:
                          type: string
                          default: tls
                          description: This only affects client connections and is used to control which
                            certificate the servers should use to authenticate
                            themselves against the client.
                      description: TLS configuration options for the server.
                    extraVolumes:
                      type: array
                      items:
                        type: object
                        x-kubernetes-preserve-unknown-fields: true
                      description: Extra volumes similar to `.spec.volumes` on a Pod to mount into
                        every container, this can be useful to for example make
                        client certificates, keytabs or similar things available
                        to processors. These volumes will be mounted into all
                        pods at `/stackable/userdata/{volumename}`. See also the
                        [external files usage
                        guide](https://docs.stackable.tech/home/25.3/nifi/usage_guide/extra-volumes).
                    listenerClass:
                      enum:
                        - cluster-internal
                        - external-unstable
                      type: string
                      default: cluster-internal
                      description: |-
                        This field controls which type of Service the Operator creates for this NifiCluster:

                        * cluster-internal: Use a ClusterIP service

                        * external-unstable: Use a NodePort service

                        This is a temporary solution with the goal to keep yaml manifests forward compatible. In the future, this setting will control which [ListenerClass](https://docs.stackable.tech/home/25.3/listener-operator/listenerclass.html) will be used to expose the service, and ListenerClass names will stay the same, allowing for a non-breaking change.
                    authentication:
                      type: array
                      items:
                        type: object
                        required:
                          - authenticationClass
                        properties:
                          oidc:
                            type: object
                            nullable: true
                            required:
                              - clientCredentialsSecret
                            properties:
                              extraScopes:
                                type: array
                                items:
                                  type: string
                                default: []
                                description: An optional list of extra scopes which get merged with the scopes
                                  defined in the [`AuthenticationClass`].
                              clientCredentialsSecret:
                                type: string
                                description: A reference to the OIDC client credentials secret. The secret
                                  contains the client id and secret.
                            description: This field contains OIDC-specific configuration. It is only
                              required in case OIDC is used.
                          authenticationClass:
                            type: string
                            description: Name of the
                              [AuthenticationClass](https://docs.stackable.tech/home/nightly/concepts/authentication)
                              used to authenticate users.
                      description: Authentication options for NiFi (required). Read more about
                        authentication in the [security
                        documentation](https://docs.stackable.tech/home/25.3/nifi/usage_guide/security).
                    hostHeaderCheck:
                      type: object
                      default:
                        allowAll: true
                        additionalAllowedHosts: []
                      properties:
                        allowAll:
                          type: boolean
                          default: true
                          description: Allow all proxy hosts by turning off host header validation. See
                            <https://github.com/stackabletech/docker-images/pull/694>
                        additionalAllowedHosts:
                          type: array
                          items:
                            type: string
                          default: []
                          description: List of proxy hosts to add to the default allow list deployed by
                            SDP containing Kubernetes Services utilized by NiFi.
                      description: Configuration of allowed proxies e.g. load balancers or Kubernetes
                        Ingress. Using a proxy that is not allowed by NiFi
                        results in a failed host header check.
                    sensitiveProperties:
                      type: object
                      required:
                        - keySecret
                      properties:
                        algorithm:
                          enum:
                            - nifiArgon2AesGcm128
                            - nifiArgon2AesGcm256
                            - nifiBcryptAesGcm128
                            - nifiBcryptAesGcm256
                            - nifiPbkdf2AesGcm128
                            - nifiPbkdf2AesGcm256
                            - nifiScryptAesGcm128
                            - nifiScryptAesGcm256
                          type: string
                          nullable: true
                          description: |-
                            This is setting the `nifi.sensitive.props.algorithm` property in NiFi. This setting configures the encryption algorithm to use to encrypt sensitive properties. Valid values are:

                            `nifiPbkdf2AesGcm256` (the default value), `nifiArgon2AesGcm256`,

                            The following algorithms are deprecated and will be removed in future versions:

                            `nifiArgon2AesGcm128`, `nifiBcryptAesGcm128`, `nifiBcryptAesGcm256`, `nifiPbkdf2AesGcm128`, `nifiScryptAesGcm128`, `nifiScryptAesGcm256`.

                            Learn more about the specifics of the algorithm parameters in the [NiFi documentation](https://nifi.apache.org/docs/nifi-docs/html/administration-guide.html#property-encryption-algorithms).
                        keySecret:
                          type: string
                          description: A reference to a Secret. The Secret needs to contain a key
                            `nifiSensitivePropsKey`. If `autoGenerate` is false
                            and this object is missing, the Operator will raise
                            an error. The encryption key needs to be at least 12
                            characters long.
                        autoGenerate:
                          type: boolean
                          default: false
                          description: Whether to generate the `keySecret` if it is missing. Defaults to
                            `false`.
                      description: These settings configure the encryption of sensitive properties in
                        NiFi processors. NiFi supports encrypting sensitive
                        properties in processors as they are written to disk.
                        You can configure the encryption algorithm and the key
                        to use. You can also let the operator generate an
                        encryption key for you.
                    createReportingTaskJob:
                      type: object
                      default:
                        enabled: true
                        podOverrides: {}
                      properties:
                        enabled:
                          type: boolean
                          default: true
                          description: Wether the Kubernetes Job should be created, defaults to true. It
                            can be helpful to disable the Job, e.g. when you
                            configOverride an authentication mechanism, which
                            the Job currently can't use to authenticate against
                            NiFi.
                        podOverrides:
                          type: object
                          default: {}
                          description: Here you can define a
                            [PodTemplateSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#podtemplatespec-v1-core)
                            to override any property that can be set on the Pod
                            of the create-reporting-task Kubernetes Job. Read
                            the [Pod overrides
                            documentation](https://docs.stackable.tech/home/25.3/concepts/overrides#pod-overrides)
                            for more information.
                          x-kubernetes-preserve-unknown-fields: true
                      description: This section creates a `create-reporting-task` Kubernetes Job,
                        which enables the export of Prometheus metrics within
                        NiFi.
                    zookeeperConfigMapName:
                      type: string
                      description: NiFi requires a ZooKeeper cluster connection to run. Provide the
                        name of the ZooKeeper [discovery
                        ConfigMap](https://docs.stackable.tech/home/25.3/concepts/service_discovery)
                        here. When using the [Stackable operator for Apache
                        ZooKeeper](https://docs.stackable.tech/home/25.3/zookeeper/)
                        to deploy a ZooKeeper cluster, this will simply be the
                        name of your ZookeeperCluster resource.
                    vectorAggregatorConfigMapName:
                      type: string
                      nullable: true
                      description: Name of the Vector aggregator [discovery
                        ConfigMap](https://docs.stackable.tech/home/25.3/concepts/service_discovery).
                        It must contain the key `ADDRESS` with the address of
                        the Vector aggregator. Follow the [logging
                        tutorial](https://docs.stackable.tech/home/25.3/tutorials/logging-vector-aggregator)
                        to learn how to configure log aggregation with Vector.
                  description: Settings that affect all roles and role groups. The settings in the
                    `clusterConfig` are cluster wide settings that do not need
                    to be configurable at role or role group level.
                clusterOperation:
                  type: object
                  default:
                    stopped: false
                    reconciliationPaused: false
                  properties:
                    stopped:
                      type: boolean
                      default: false
                      description: Flag to stop the cluster. This means all deployed resources (e.g.
                        Services, StatefulSets, ConfigMaps) are kept but all
                        deployed Pods (e.g. replicas from a StatefulSet) are
                        scaled to 0 and therefore stopped and removed. If
                        applied at the same time with `reconciliationPaused`,
                        the latter will pause reconciliation and `stopped` will
                        take no effect until `reconciliationPaused` is set to
                        false or removed.
                    reconciliationPaused:
                      type: boolean
                      default: false
                      description: Flag to stop cluster reconciliation by the operator. This means
                        that all changes in the custom resource spec are ignored
                        until this flag is set to false or removed. The operator
                        will however still watch the deployed resources at the
                        time and update the custom resource status field. If
                        applied at the same time with `stopped`,
                        `reconciliationPaused` will take precedence over
                        `stopped` and stop the reconciliation immediately.
                  description: "[Cluster
                    operations](https://docs.stackable.tech/home/25.3/concepts/\
                    operations/cluster_operations) properties, allow stopping
                    the product instance as well as pausing reconciliation."
              description: A NiFi cluster stacklet. This resource is managed by the Stackable
                operator for Apache NiFi. Find more information on how to use it
                and the resources that the operator generates in the [operator
                documentation](https://docs.stackable.tech/home/25.3/nifi/).
            status:
              type: object
              nullable: true
              properties:
                conditions:
                  type: array
                  items:
                    type: object
                    required:
                      - status
                      - type
                    properties:
                      type:
                        enum:
                          - Available
                          - Degraded
                          - Progressing
                          - ReconciliationPaused
                          - Stopped
                        type: string
                        description: Type of deployment condition.
                      reason:
                        type: string
                        nullable: true
                        description: The reason for the condition's last transition.
                      status:
                        enum:
                          - "True"
                          - "False"
                          - Unknown
                        type: string
                        description: Status of the condition, one of True, False, Unknown.
                      message:
                        type: string
                        nullable: true
                        description: A human readable message indicating details about the transition.
                      lastUpdateTime:
                        type: string
                        format: date-time
                        nullable: true
                        description: The last time this condition was updated.
                      lastTransitionTime:
                        type: string
                        format: date-time
                        nullable: true
                        description: Last time the condition transitioned from one status to another.
                  default: []
                deployed_version:
                  type: string
                  nullable: true
          description: Auto-generated derived type for NifiClusterSpec via `CustomResource`
      served: true
      storage: true
      subresources:
        status: {}
      additionalPrinterColumns: []
metadata:
  name: nificlusters.nifi.stackable.tech
  annotations:
    helm.sh/resource-policy: keep
apiVersion: apiextensions.k8s.io/v1
