apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.18.0
  creationTimestamp: "2026-04-06T12:15:08Z"
  generation: 1
  name: rabbitmqs.rabbitmq.openstack.org
  resourceVersion: "38764"
  uid: 7388e7c8-3d4f-4510-a152-a409f2436a11
spec:
  conversion:
    strategy: None
  group: rabbitmq.openstack.org
  names:
    categories:
    - all
    - rabbitmq
    kind: RabbitMq
    listKind: RabbitMqList
    plural: rabbitmqs
    singular: rabbitmq
  scope: Namespaced
  versions:
  - additionalPrinterColumns:
    - description: Status
      jsonPath: .status.conditions[0].status
      name: Status
      type: string
    - description: Message
      jsonPath: .status.conditions[0].message
      name: Message
      type: string
    name: v1beta1
    schema:
      openAPIV3Schema:
        description: RabbitMq is the Schema for the rabbitmqs API
        properties:
          apiVersion:
            description: |-
              APIVersion defines the versioned schema of this representation of an object.
              Servers should convert recognized schemas to the latest internal value, and
              may reject unrecognized values.
              More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
            type: string
          kind:
            description: |-
              Kind is a string value representing the REST resource this object represents.
              Servers may infer this from the endpoint the client submits requests to.
              Cannot be updated.
              In CamelCase.
              More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
            type: string
          metadata:
            type: object
          spec:
            description: RabbitMqSpec defines the desired state of RabbitMq
            properties:
              affinity:
                description: Affinity scheduling rules to be applied on created Pods.
                properties:
                  nodeAffinity:
                    description: Describes node affinity scheduling rules for the
                      pod.
                    properties:
                      preferredDuringSchedulingIgnoredDuringExecution:
                        description: |-
                          The scheduler will prefer to schedule pods to nodes that satisfy
                          the affinity expressions specified by this field, but it may choose
                          a node that violates one or more of the expressions. The node that is
                          most preferred is the one with the greatest sum of weights, i.e.
                          for each node that meets all of the scheduling requirements (resource
                          request, requiredDuringScheduling affinity expressions, etc.),
                          compute a sum by iterating through the elements of this field and adding
                          "weight" to the sum if the node matches the corresponding matchExpressions; the
                          node(s) with the highest sum are the most preferred.
                        items:
                          description: |-
                            An empty preferred scheduling term matches all objects with implicit weight 0
                            (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                          properties:
                            preference:
                              description: A node selector term, associated with the
                                corresponding weight.
                              properties:
                                matchExpressions:
                                  description: A list of node selector requirements
                                    by node's labels.
                                  items:
                                    description: |-
                                      A node selector requirement is a selector that contains values, a key, and an operator
                                      that relates the key and values.
                                    properties:
                                      key:
                                        description: The label key that the selector
                                          applies to.
                                        type: string
                                      operator:
                                        description: |-
                                          Represents a key's relationship to a set of values.
                                          Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                        type: string
                                      values:
                                        description: |-
                                          An array of string values. If the operator is In or NotIn,
                                          the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                          the values array must be empty. If the operator is Gt or Lt, the values
                                          array must have a single element, which will be interpreted as an integer.
                                          This array is replaced during a strategic merge patch.
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                  x-kubernetes-list-type: atomic
                                matchFields:
                                  description: A list of node selector requirements
                                    by node's fields.
                                  items:
                                    description: |-
                                      A node selector requirement is a selector that contains values, a key, and an operator
                                      that relates the key and values.
                                    properties:
                                      key:
                                        description: The label key that the selector
                                          applies to.
                                        type: string
                                      operator:
                                        description: |-
                                          Represents a key's relationship to a set of values.
                                          Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                        type: string
                                      values:
                                        description: |-
                                          An array of string values. If the operator is In or NotIn,
                                          the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                          the values array must be empty. If the operator is Gt or Lt, the values
                                          array must have a single element, which will be interpreted as an integer.
                                          This array is replaced during a strategic merge patch.
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                  x-kubernetes-list-type: atomic
                              type: object
                              x-kubernetes-map-type: atomic
                            weight:
                              description: Weight associated with matching the corresponding
                                nodeSelectorTerm, in the range 1-100.
                              format: int32
                              type: integer
                          required:
                          - preference
                          - weight
                          type: object
                        type: array
                        x-kubernetes-list-type: atomic
                      requiredDuringSchedulingIgnoredDuringExecution:
                        description: |-
                          If the affinity requirements specified by this field are not met at
                          scheduling time, the pod will not be scheduled onto the node.
                          If the affinity requirements specified by this field cease to be met
                          at some point during pod execution (e.g. due to an update), the system
                          may or may not try to eventually evict the pod from its node.
                        properties:
                          nodeSelectorTerms:
                            description: Required. A list of node selector terms.
                              The terms are ORed.
                            items:
                              description: |-
                                A null or empty node selector term matches no objects. The requirements of
                                them are ANDed.
                                The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                              properties:
                                matchExpressions:
                                  description: A list of node selector requirements
                                    by node's labels.
                                  items:
                                    description: |-
                                      A node selector requirement is a selector that contains values, a key, and an operator
                                      that relates the key and values.
                                    properties:
                                      key:
                                        description: The label key that the selector
                                          applies to.
                                        type: string
                                      operator:
                                        description: |-
                                          Represents a key's relationship to a set of values.
                                          Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                        type: string
                                      values:
                                        description: |-
                                          An array of string values. If the operator is In or NotIn,
                                          the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                          the values array must be empty. If the operator is Gt or Lt, the values
                                          array must have a single element, which will be interpreted as an integer.
                                          This array is replaced during a strategic merge patch.
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                  x-kubernetes-list-type: atomic
                                matchFields:
                                  description: A list of node selector requirements
                                    by node's fields.
                                  items:
                                    description: |-
                                      A node selector requirement is a selector that contains values, a key, and an operator
                                      that relates the key and values.
                                    properties:
                                      key:
                                        description: The label key that the selector
                                          applies to.
                                        type: string
                                      operator:
                                        description: |-
                                          Represents a key's relationship to a set of values.
                                          Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                        type: string
                                      values:
                                        description: |-
                                          An array of string values. If the operator is In or NotIn,
                                          the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                          the values array must be empty. If the operator is Gt or Lt, the values
                                          array must have a single element, which will be interpreted as an integer.
                                          This array is replaced during a strategic merge patch.
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                  x-kubernetes-list-type: atomic
                              type: object
                              x-kubernetes-map-type: atomic
                            type: array
                            x-kubernetes-list-type: atomic
                        required:
                        - nodeSelectorTerms
                        type: object
                        x-kubernetes-map-type: atomic
                    type: object
                  podAffinity:
                    description: Describes pod affinity scheduling rules (e.g. co-locate
                      this pod in the same node, zone, etc. as some other pod(s)).
                    properties:
                      preferredDuringSchedulingIgnoredDuringExecution:
                        description: |-
                          The scheduler will prefer to schedule pods to nodes that satisfy
                          the affinity expressions specified by this field, but it may choose
                          a node that violates one or more of the expressions. The node that is
                          most preferred is the one with the greatest sum of weights, i.e.
                          for each node that meets all of the scheduling requirements (resource
                          request, requiredDuringScheduling affinity expressions, etc.),
                          compute a sum by iterating through the elements of this field and adding
                          "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                          node(s) with the highest sum are the most preferred.
                        items:
                          description: The weights of all of the matched WeightedPodAffinityTerm
                            fields are added per-node to find the most preferred node(s)
                          properties:
                            podAffinityTerm:
                              description: Required. A pod affinity term, associated
                                with the corresponding weight.
                              properties:
                                labelSelector:
                                  description: |-
                                    A label query over a set of resources, in this case pods.
                                    If it's null, this PodAffinityTerm matches with no Pods.
                                  properties:
                                    matchExpressions:
                                      description: matchExpressions is a list of label
                                        selector requirements. The requirements are
                                        ANDed.
                                      items:
                                        description: |-
                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                          relates the key and values.
                                        properties:
                                          key:
                                            description: key is the label key that
                                              the selector applies to.
                                            type: string
                                          operator:
                                            description: |-
                                              operator represents a key's relationship to a set of values.
                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                            type: string
                                          values:
                                            description: |-
                                              values is an array of string values. If the operator is In or NotIn,
                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                              the values array must be empty. This array is replaced during a strategic
                                              merge patch.
                                            items:
                                              type: string
                                            type: array
                                            x-kubernetes-list-type: atomic
                                        required:
                                        - key
                                        - operator
                                        type: object
                                      type: array
                                      x-kubernetes-list-type: atomic
                                    matchLabels:
                                      additionalProperties:
                                        type: string
                                      description: |-
                                        matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                        map is equivalent to an element of matchExpressions, whose key field is "key", the
                                        operator is "In", and the values array contains only "value". The requirements are ANDed.
                                      type: object
                                  type: object
                                  x-kubernetes-map-type: atomic
                                matchLabelKeys:
                                  description: |-
                                    MatchLabelKeys is a set of pod label keys to select which pods will
                                    be taken into consideration. The keys are used to lookup values from the
                                    incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                    to select the group of existing pods which pods will be taken into consideration
                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                    pod labels will be ignored. The default value is empty.
                                    The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                    Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                    This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                  items:
                                    type: string
                                  type: array
                                  x-kubernetes-list-type: atomic
                                mismatchLabelKeys:
                                  description: |-
                                    MismatchLabelKeys is a set of pod label keys to select which pods will
                                    be taken into consideration. The keys are used to lookup values from the
                                    incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                    to select the group of existing pods which pods will be taken into consideration
                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                    pod labels will be ignored. The default value is empty.
                                    The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                    Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                    This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                  items:
                                    type: string
                                  type: array
                                  x-kubernetes-list-type: atomic
                                namespaceSelector:
                                  description: |-
                                    A label query over the set of namespaces that the term applies to.
                                    The term is applied to the union of the namespaces selected by this field
                                    and the ones listed in the namespaces field.
                                    null selector and null or empty namespaces list means "this pod's namespace".
                                    An empty selector ({}) matches all namespaces.
                                  properties:
                                    matchExpressions:
                                      description: matchExpressions is a list of label
                                        selector requirements. The requirements are
                                        ANDed.
                                      items:
                                        description: |-
                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                          relates the key and values.
                                        properties:
                                          key:
                                            description: key is the label key that
                                              the selector applies to.
                                            type: string
                                          operator:
                                            description: |-
                                              operator represents a key's relationship to a set of values.
                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                            type: string
                                          values:
                                            description: |-
                                              values is an array of string values. If the operator is In or NotIn,
                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                              the values array must be empty. This array is replaced during a strategic
                                              merge patch.
                                            items:
                                              type: string
                                            type: array
                                            x-kubernetes-list-type: atomic
                                        required:
                                        - key
                                        - operator
                                        type: object
                                      type: array
                                      x-kubernetes-list-type: atomic
                                    matchLabels:
                                      additionalProperties:
                                        type: string
                                      description: |-
                                        matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                        map is equivalent to an element of matchExpressions, whose key field is "key", the
                                        operator is "In", and the values array contains only "value". The requirements are ANDed.
                                      type: object
                                  type: object
                                  x-kubernetes-map-type: atomic
                                namespaces:
                                  description: |-
                                    namespaces specifies a static list of namespace names that the term applies to.
                                    The term is applied to the union of the namespaces listed in this field
                                    and the ones selected by namespaceSelector.
                                    null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                  items:
                                    type: string
                                  type: array
                                  x-kubernetes-list-type: atomic
                                topologyKey:
                                  description: |-
                                    This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                    the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                    whose value of the label with key topologyKey matches that of any node on which any of the
                                    selected pods is running.
                                    Empty topologyKey is not allowed.
                                  type: string
                              required:
                              - topologyKey
                              type: object
                            weight:
                              description: |-
                                weight associated with matching the corresponding podAffinityTerm,
                                in the range 1-100.
                              format: int32
                              type: integer
                          required:
                          - podAffinityTerm
                          - weight
                          type: object
                        type: array
                        x-kubernetes-list-type: atomic
                      requiredDuringSchedulingIgnoredDuringExecution:
                        description: |-
                          If the affinity requirements specified by this field are not met at
                          scheduling time, the pod will not be scheduled onto the node.
                          If the affinity requirements specified by this field cease to be met
                          at some point during pod execution (e.g. due to a pod label update), the
                          system may or may not try to eventually evict the pod from its node.
                          When there are multiple elements, the lists of nodes corresponding to each
                          podAffinityTerm are intersected, i.e. all terms must be satisfied.
                        items:
                          description: |-
                            Defines a set of pods (namely those matching the labelSelector
                            relative to the given namespace(s)) that this pod should be
                            co-located (affinity) or not co-located (anti-affinity) with,
                            where co-located is defined as running on a node whose value of
                            the label with key <topologyKey> matches that of any node on which
                            a pod of the set of pods is running
                          properties:
                            labelSelector:
                              description: |-
                                A label query over a set of resources, in this case pods.
                                If it's null, this PodAffinityTerm matches with no Pods.
                              properties:
                                matchExpressions:
                                  description: matchExpressions is a list of label
                                    selector requirements. The requirements are ANDed.
                                  items:
                                    description: |-
                                      A label selector requirement is a selector that contains values, a key, and an operator that
                                      relates the key and values.
                                    properties:
                                      key:
                                        description: key is the label key that the
                                          selector applies to.
                                        type: string
                                      operator:
                                        description: |-
                                          operator represents a key's relationship to a set of values.
                                          Valid operators are In, NotIn, Exists and DoesNotExist.
                                        type: string
                                      values:
                                        description: |-
                                          values is an array of string values. If the operator is In or NotIn,
                                          the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                          the values array must be empty. This array is replaced during a strategic
                                          merge patch.
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                  x-kubernetes-list-type: atomic
                                matchLabels:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                    map is equivalent to an element of matchExpressions, whose key field is "key", the
                                    operator is "In", and the values array contains only "value". The requirements are ANDed.
                                  type: object
                              type: object
                              x-kubernetes-map-type: atomic
                            matchLabelKeys:
                              description: |-
                                MatchLabelKeys is a set of pod label keys to select which pods will
                                be taken into consideration. The keys are used to lookup values from the
                                incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                to select the group of existing pods which pods will be taken into consideration
                                for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                pod labels will be ignored. The default value is empty.
                                The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                              items:
                                type: string
                              type: array
                              x-kubernetes-list-type: atomic
                            mismatchLabelKeys:
                              description: |-
                                MismatchLabelKeys is a set of pod label keys to select which pods will
                                be taken into consideration. The keys are used to lookup values from the
                                incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                to select the group of existing pods which pods will be taken into consideration
                                for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                pod labels will be ignored. The default value is empty.
                                The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                              items:
                                type: string
                              type: array
                              x-kubernetes-list-type: atomic
                            namespaceSelector:
                              description: |-
                                A label query over the set of namespaces that the term applies to.
                                The term is applied to the union of the namespaces selected by this field
                                and the ones listed in the namespaces field.
                                null selector and null or empty namespaces list means "this pod's namespace".
                                An empty selector ({}) matches all namespaces.
                              properties:
                                matchExpressions:
                                  description: matchExpressions is a list of label
                                    selector requirements. The requirements are ANDed.
                                  items:
                                    description: |-
                                      A label selector requirement is a selector that contains values, a key, and an operator that
                                      relates the key and values.
                                    properties:
                                      key:
                                        description: key is the label key that the
                                          selector applies to.
                                        type: string
                                      operator:
                                        description: |-
                                          operator represents a key's relationship to a set of values.
                                          Valid operators are In, NotIn, Exists and DoesNotExist.
                                        type: string
                                      values:
                                        description: |-
                                          values is an array of string values. If the operator is In or NotIn,
                                          the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                          the values array must be empty. This array is replaced during a strategic
                                          merge patch.
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                  x-kubernetes-list-type: atomic
                                matchLabels:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                    map is equivalent to an element of matchExpressions, whose key field is "key", the
                                    operator is "In", and the values array contains only "value". The requirements are ANDed.
                                  type: object
                              type: object
                              x-kubernetes-map-type: atomic
                            namespaces:
                              description: |-
                                namespaces specifies a static list of namespace names that the term applies to.
                                The term is applied to the union of the namespaces listed in this field
                                and the ones selected by namespaceSelector.
                                null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                              items:
                                type: string
                              type: array
                              x-kubernetes-list-type: atomic
                            topologyKey:
                              description: |-
                                This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                whose value of the label with key topologyKey matches that of any node on which any of the
                                selected pods is running.
                                Empty topologyKey is not allowed.
                              type: string
                          required:
                          - topologyKey
                          type: object
                        type: array
                        x-kubernetes-list-type: atomic
                    type: object
                  podAntiAffinity:
                    description: Describes pod anti-affinity scheduling rules (e.g.
                      avoid putting this pod in the same node, zone, etc. as some
                      other pod(s)).
                    properties:
                      preferredDuringSchedulingIgnoredDuringExecution:
                        description: |-
                          The scheduler will prefer to schedule pods to nodes that satisfy
                          the anti-affinity expressions specified by this field, but it may choose
                          a node that violates one or more of the expressions. The node that is
                          most preferred is the one with the greatest sum of weights, i.e.
                          for each node that meets all of the scheduling requirements (resource
                          request, requiredDuringScheduling anti-affinity expressions, etc.),
                          compute a sum by iterating through the elements of this field and adding
                          "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                          node(s) with the highest sum are the most preferred.
                        items:
                          description: The weights of all of the matched WeightedPodAffinityTerm
                            fields are added per-node to find the most preferred node(s)
                          properties:
                            podAffinityTerm:
                              description: Required. A pod affinity term, associated
                                with the corresponding weight.
                              properties:
                                labelSelector:
                                  description: |-
                                    A label query over a set of resources, in this case pods.
                                    If it's null, this PodAffinityTerm matches with no Pods.
                                  properties:
                                    matchExpressions:
                                      description: matchExpressions is a list of label
                                        selector requirements. The requirements are
                                        ANDed.
                                      items:
                                        description: |-
                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                          relates the key and values.
                                        properties:
                                          key:
                                            description: key is the label key that
                                              the selector applies to.
                                            type: string
                                          operator:
                                            description: |-
                                              operator represents a key's relationship to a set of values.
                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                            type: string
                                          values:
                                            description: |-
                                              values is an array of string values. If the operator is In or NotIn,
                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                              the values array must be empty. This array is replaced during a strategic
                                              merge patch.
                                            items:
                                              type: string
                                            type: array
                                            x-kubernetes-list-type: atomic
                                        required:
                                        - key
                                        - operator
                                        type: object
                                      type: array
                                      x-kubernetes-list-type: atomic
                                    matchLabels:
                                      additionalProperties:
                                        type: string
                                      description: |-
                                        matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                        map is equivalent to an element of matchExpressions, whose key field is "key", the
                                        operator is "In", and the values array contains only "value". The requirements are ANDed.
                                      type: object
                                  type: object
                                  x-kubernetes-map-type: atomic
                                matchLabelKeys:
                                  description: |-
                                    MatchLabelKeys is a set of pod label keys to select which pods will
                                    be taken into consideration. The keys are used to lookup values from the
                                    incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                    to select the group of existing pods which pods will be taken into consideration
                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                    pod labels will be ignored. The default value is empty.
                                    The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                    Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                    This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                  items:
                                    type: string
                                  type: array
                                  x-kubernetes-list-type: atomic
                                mismatchLabelKeys:
                                  description: |-
                                    MismatchLabelKeys is a set of pod label keys to select which pods will
                                    be taken into consideration. The keys are used to lookup values from the
                                    incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                    to select the group of existing pods which pods will be taken into consideration
                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                    pod labels will be ignored. The default value is empty.
                                    The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                    Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                    This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                                  items:
                                    type: string
                                  type: array
                                  x-kubernetes-list-type: atomic
                                namespaceSelector:
                                  description: |-
                                    A label query over the set of namespaces that the term applies to.
                                    The term is applied to the union of the namespaces selected by this field
                                    and the ones listed in the namespaces field.
                                    null selector and null or empty namespaces list means "this pod's namespace".
                                    An empty selector ({}) matches all namespaces.
                                  properties:
                                    matchExpressions:
                                      description: matchExpressions is a list of label
                                        selector requirements. The requirements are
                                        ANDed.
                                      items:
                                        description: |-
                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                          relates the key and values.
                                        properties:
                                          key:
                                            description: key is the label key that
                                              the selector applies to.
                                            type: string
                                          operator:
                                            description: |-
                                              operator represents a key's relationship to a set of values.
                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                            type: string
                                          values:
                                            description: |-
                                              values is an array of string values. If the operator is In or NotIn,
                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                              the values array must be empty. This array is replaced during a strategic
                                              merge patch.
                                            items:
                                              type: string
                                            type: array
                                            x-kubernetes-list-type: atomic
                                        required:
                                        - key
                                        - operator
                                        type: object
                                      type: array
                                      x-kubernetes-list-type: atomic
                                    matchLabels:
                                      additionalProperties:
                                        type: string
                                      description: |-
                                        matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                        map is equivalent to an element of matchExpressions, whose key field is "key", the
                                        operator is "In", and the values array contains only "value". The requirements are ANDed.
                                      type: object
                                  type: object
                                  x-kubernetes-map-type: atomic
                                namespaces:
                                  description: |-
                                    namespaces specifies a static list of namespace names that the term applies to.
                                    The term is applied to the union of the namespaces listed in this field
                                    and the ones selected by namespaceSelector.
                                    null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                  items:
                                    type: string
                                  type: array
                                  x-kubernetes-list-type: atomic
                                topologyKey:
                                  description: |-
                                    This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                    the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                    whose value of the label with key topologyKey matches that of any node on which any of the
                                    selected pods is running.
                                    Empty topologyKey is not allowed.
                                  type: string
                              required:
                              - topologyKey
                              type: object
                            weight:
                              description: |-
                                weight associated with matching the corresponding podAffinityTerm,
                                in the range 1-100.
                              format: int32
                              type: integer
                          required:
                          - podAffinityTerm
                          - weight
                          type: object
                        type: array
                        x-kubernetes-list-type: atomic
                      requiredDuringSchedulingIgnoredDuringExecution:
                        description: |-
                          If the anti-affinity requirements specified by this field are not met at
                          scheduling time, the pod will not be scheduled onto the node.
                          If the anti-affinity requirements specified by this field cease to be met
                          at some point during pod execution (e.g. due to a pod label update), the
                          system may or may not try to eventually evict the pod from its node.
                          When there are multiple elements, the lists of nodes corresponding to each
                          podAffinityTerm are intersected, i.e. all terms must be satisfied.
                        items:
                          description: |-
                            Defines a set of pods (namely those matching the labelSelector
                            relative to the given namespace(s)) that this pod should be
                            co-located (affinity) or not co-located (anti-affinity) with,
                            where co-located is defined as running on a node whose value of
                            the label with key <topologyKey> matches that of any node on which
                            a pod of the set of pods is running
                          properties:
                            labelSelector:
                              description: |-
                                A label query over a set of resources, in this case pods.
                                If it's null, this PodAffinityTerm matches with no Pods.
                              properties:
                                matchExpressions:
                                  description: matchExpressions is a list of label
                                    selector requirements. The requirements are ANDed.
                                  items:
                                    description: |-
                                      A label selector requirement is a selector that contains values, a key, and an operator that
                                      relates the key and values.
                                    properties:
                                      key:
                                        description: key is the label key that the
                                          selector applies to.
                                        type: string
                                      operator:
                                        description: |-
                                          operator represents a key's relationship to a set of values.
                                          Valid operators are In, NotIn, Exists and DoesNotExist.
                                        type: string
                                      values:
                                        description: |-
                                          values is an array of string values. If the operator is In or NotIn,
                                          the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                          the values array must be empty. This array is replaced during a strategic
                                          merge patch.
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                  x-kubernetes-list-type: atomic
                                matchLabels:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                    map is equivalent to an element of matchExpressions, whose key field is "key", the
                                    operator is "In", and the values array contains only "value". The requirements are ANDed.
                                  type: object
                              type: object
                              x-kubernetes-map-type: atomic
                            matchLabelKeys:
                              description: |-
                                MatchLabelKeys is a set of pod label keys to select which pods will
                                be taken into consideration. The keys are used to lookup values from the
                                incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
                                to select the group of existing pods which pods will be taken into consideration
                                for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                pod labels will be ignored. The default value is empty.
                                The same key is forbidden to exist in both matchLabelKeys and labelSelector.
                                Also, matchLabelKeys cannot be set when labelSelector isn't set.
                                This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                              items:
                                type: string
                              type: array
                              x-kubernetes-list-type: atomic
                            mismatchLabelKeys:
                              description: |-
                                MismatchLabelKeys is a set of pod label keys to select which pods will
                                be taken into consideration. The keys are used to lookup values from the
                                incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
                                to select the group of existing pods which pods will be taken into consideration
                                for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                pod labels will be ignored. The default value is empty.
                                The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
                                Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
                                This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
                              items:
                                type: string
                              type: array
                              x-kubernetes-list-type: atomic
                            namespaceSelector:
                              description: |-
                                A label query over the set of namespaces that the term applies to.
                                The term is applied to the union of the namespaces selected by this field
                                and the ones listed in the namespaces field.
                                null selector and null or empty namespaces list means "this pod's namespace".
                                An empty selector ({}) matches all namespaces.
                              properties:
                                matchExpressions:
                                  description: matchExpressions is a list of label
                                    selector requirements. The requirements are ANDed.
                                  items:
                                    description: |-
                                      A label selector requirement is a selector that contains values, a key, and an operator that
                                      relates the key and values.
                                    properties:
                                      key:
                                        description: key is the label key that the
                                          selector applies to.
                                        type: string
                                      operator:
                                        description: |-
                                          operator represents a key's relationship to a set of values.
                                          Valid operators are In, NotIn, Exists and DoesNotExist.
                                        type: string
                                      values:
                                        description: |-
                                          values is an array of string values. If the operator is In or NotIn,
                                          the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                          the values array must be empty. This array is replaced during a strategic
                                          merge patch.
                                        items:
                                          type: string
                                        type: array
                                        x-kubernetes-list-type: atomic
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                  x-kubernetes-list-type: atomic
                                matchLabels:
                                  additionalProperties:
                                    type: string
                                  description: |-
                                    matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
                                    map is equivalent to an element of matchExpressions, whose key field is "key", the
                                    operator is "In", and the values array contains only "value". The requirements are ANDed.
                                  type: object
                              type: object
                              x-kubernetes-map-type: atomic
                            namespaces:
                              description: |-
                                namespaces specifies a static list of namespace names that the term applies to.
                                The term is applied to the union of the namespaces listed in this field
                                and the ones selected by namespaceSelector.
                                null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                              items:
                                type: string
                              type: array
                              x-kubernetes-list-type: atomic
                            topologyKey:
                              description: |-
                                This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                whose value of the label with key topologyKey matches that of any node on which any of the
                                selected pods is running.
                                Empty topologyKey is not allowed.
                              type: string
                          required:
                          - topologyKey
                          type: object
                        type: array
                        x-kubernetes-list-type: atomic
                    type: object
                type: object
              containerImage:
                description: Name of the rabbitmq container image to run (will be
                  set to environmental default if empty)
                type: string
              delayStartSeconds:
                default: 30
                description: |-
                  DelayStartSeconds is the time the init container (`setup-container`) will sleep before terminating.
                  This effectively delays the time between starting the Pod and starting the `rabbitmq` container.
                  RabbitMQ relies on up-to-date DNS entries early during peer discovery.
                  The purpose of this artificial delay is to ensure that DNS entries are up-to-date when booting RabbitMQ.
                  For more information, see https://github.com/kubernetes/kubernetes/issues/92559
                  If your Kubernetes DNS backend is configured with a low DNS cache value or publishes not ready addresses
                  promptly, you can decrase this value or set it to 0.
                format: int32
                minimum: 0
                type: integer
              nodeSelector:
                additionalProperties:
                  type: string
                description: NodeSelector to target subset of worker nodes running
                  this service
                type: object
              override:
                description: Provides the ability to override the generated manifest
                  of several child resources.
                properties:
                  service:
                    description: Override configuration for the Service created to
                      serve traffic to the cluster.
                    properties:
                      metadata:
                        description: |-
                          EmbeddedLabelsAnnotations is an embedded subset of the fields included in k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta.
                          Only labels and annotations are included.
                        properties:
                          annotations:
                            additionalProperties:
                              type: string
                            description: |-
                              Annotations is an unstructured key value map stored with a resource that may be
                              set by external tools to store and retrieve arbitrary metadata. They are not
                              queryable and should be preserved when modifying objects.
                              More info: http://kubernetes.io/docs/user-guide/annotations
                            type: object
                          labels:
                            additionalProperties:
                              type: string
                            description: |-
                              Map of string keys and values that can be used to organize and categorize
                              (scope and select) objects. May match selectors of replication controllers
                              and services.
                              More info: http://kubernetes.io/docs/user-guide/labels
                            type: object
                        type: object
                      spec:
                        description: |-
                          Spec defines the behavior of a Service.
                          https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
                        properties:
                          allocateLoadBalancerNodePorts:
                            description: |-
                              allocateLoadBalancerNodePorts defines if NodePorts will be automatically
                              allocated for services with type LoadBalancer.  Default is "true". It
                              may be set to "false" if the cluster load-balancer does not rely on
                              NodePorts.  If the caller requests specific NodePorts (by specifying a
                              value), those requests will be respected, regardless of this field.
                              This field may only be set for services with type LoadBalancer and will
                              be cleared if the type is changed to any other type.
                            type: boolean
                          clusterIP:
                            description: |-
                              clusterIP is the IP address of the service and is usually assigned
                              randomly. If an address is specified manually, is in-range (as per
                              system configuration), and is not in use, it will be allocated to the
                              service; otherwise creation of the service will fail. This field may not
                              be changed through updates unless the type field is also being changed
                              to ExternalName (which requires this field to be blank) or the type
                              field is being changed from ExternalName (in which case this field may
                              optionally be specified, as describe above).  Valid values are "None",
                              empty string (""), or a valid IP address. Setting this to "None" makes a
                              "headless service" (no virtual IP), which is useful when direct endpoint
                              connections are preferred and proxying is not required.  Only applies to
                              types ClusterIP, NodePort, and LoadBalancer. If this field is specified
                              when creating a Service of type ExternalName, creation will fail. This
                              field will be wiped when updating a Service to type ExternalName.
                              More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
                            type: string
                          clusterIPs:
                            description: |-
                              ClusterIPs is a list of IP addresses assigned to this service, and are
                              usually assigned randomly.  If an address is specified manually, is
                              in-range (as per system configuration), and is not in use, it will be
                              allocated to the service; otherwise creation of the service will fail.
                              This field may not be changed through updates unless the type field is
                              also being changed to ExternalName (which requires this field to be
                              empty) or the type field is being changed from ExternalName (in which
                              case this field may optionally be specified, as describe above).  Valid
                              values are "None", empty string (""), or a valid IP address.  Setting
                              this to "None" makes a "headless service" (no virtual IP), which is
                              useful when direct endpoint connections are preferred and proxying is
                              not required.  Only applies to types ClusterIP, NodePort, and
                              LoadBalancer. If this field is specified when creating a Service of type
                              ExternalName, creation will fail. This field will be wiped when updating
                              a Service to type ExternalName.  If this field is not specified, it will
                              be initialized from the clusterIP field.  If this field is specified,
                              clients must ensure that clusterIPs[0] and clusterIP have the same
                              value.

                              This field may hold a maximum of two entries (dual-stack IPs, in either order).
                              These IPs must correspond to the values of the ipFamilies field. Both
                              clusterIPs and ipFamilies are governed by the ipFamilyPolicy field.
                              More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
                            items:
                              type: string
                            type: array
                            x-kubernetes-list-type: atomic
                          externalIPs:
                            description: |-
                              externalIPs is a list of IP addresses for which nodes in the cluster
                              will also accept traffic for this service.  These IPs are not managed by
                              Kubernetes.  The user is responsible for ensuring that traffic arrives
                              at a node with this IP.  A common example is external load-balancers
                              that are not part of the Kubernetes system.
                            items:
                              type: string
                            type: array
                            x-kubernetes-list-type: atomic
                          externalName:
                            description: |-
                              externalName is the external reference that discovery mechanisms will
                              return as an alias for this service (e.g. a DNS CNAME record). No
                              proxying will be involved.  Must be a lowercase RFC-1123 hostname
                              (https://tools.ietf.org/html/rfc1123) and requires `type` to be "ExternalName".
                            type: string
                          externalTrafficPolicy:
                            description: |-
                              externalTrafficPolicy describes how nodes distribute service traffic they
                              receive on one of the Service's "externally-facing" addresses (NodePorts,
                              ExternalIPs, and LoadBalancer IPs). If set to "Local", the proxy will configure
                              the service in a way that assumes that external load balancers will take care
                              of balancing the service traffic between nodes, and so each node will deliver
                              traffic only to the node-local endpoints of the service, without masquerading
                              the client source IP. (Traffic mistakenly sent to a node with no endpoints will
                              be dropped.) The default value, "Cluster", uses the standard behavior of
                              routing to all endpoints evenly (possibly modified by topology and other
                              features). Note that traffic sent to an External IP or LoadBalancer IP from
                              within the cluster will always get "Cluster" semantics, but clients sending to
                              a NodePort from within the cluster may need to take traffic policy into account
                              when picking a node.
                            type: string
                          healthCheckNodePort:
                            description: |-
                              healthCheckNodePort specifies the healthcheck nodePort for the service.
                              This only applies when type is set to LoadBalancer and
                              externalTrafficPolicy is set to Local. If a value is specified, is
                              in-range, and is not in use, it will be used.  If not specified, a value
                              will be automatically allocated.  External systems (e.g. load-balancers)
                              can use this port to determine if a given node holds endpoints for this
                              service or not.  If this field is specified when creating a Service
                              which does not need it, creation will fail. This field will be wiped
                              when updating a Service to no longer need it (e.g. changing type).
                              This field cannot be updated once set.
                            format: int32
                            type: integer
                          internalTrafficPolicy:
                            description: |-
                              InternalTrafficPolicy describes how nodes distribute service traffic they
                              receive on the ClusterIP. If set to "Local", the proxy will assume that pods
                              only want to talk to endpoints of the service on the same node as the pod,
                              dropping the traffic if there are no local endpoints. The default value,
                              "Cluster", uses the standard behavior of routing to all endpoints evenly
                              (possibly modified by topology and other features).
                            type: string
                          ipFamilies:
                            description: |-
                              IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this
                              service. This field is usually assigned automatically based on cluster
                              configuration and the ipFamilyPolicy field. If this field is specified
                              manually, the requested family is available in the cluster,
                              and ipFamilyPolicy allows it, it will be used; otherwise creation of
                              the service will fail. This field is conditionally mutable: it allows
                              for adding or removing a secondary IP family, but it does not allow
                              changing the primary IP family of the Service. Valid values are "IPv4"
                              and "IPv6".  This field only applies to Services of types ClusterIP,
                              NodePort, and LoadBalancer, and does apply to "headless" services.
                              This field will be wiped when updating a Service to type ExternalName.

                              This field may hold a maximum of two entries (dual-stack families, in
                              either order).  These families must correspond to the values of the
                              clusterIPs field, if specified. Both clusterIPs and ipFamilies are
                              governed by the ipFamilyPolicy field.
                            items:
                              description: |-
                                IPFamily represents the IP Family (IPv4 or IPv6). This type is used
                                to express the family of an IP expressed by a type (e.g. service.spec.ipFamilies).
                              type: string
                            type: array
                            x-kubernetes-list-type: atomic
                          ipFamilyPolicy:
                            description: |-
                              IPFamilyPolicy represents the dual-stack-ness requested or required by
                              this Service. If there is no value provided, then this field will be set
                              to SingleStack. Services can be "SingleStack" (a single IP family),
                              "PreferDualStack" (two IP families on dual-stack configured clusters or
                              a single IP family on single-stack clusters), or "RequireDualStack"
                              (two IP families on dual-stack configured clusters, otherwise fail). The
                              ipFamilies and clusterIPs fields depend on the value of this field. This
                              field will be wiped when updating a service to type ExternalName.
                            type: string
                          loadBalancerClass:
                            description: |-
                              loadBalancerClass is the class of the load balancer implementation this Service belongs to.
                              If specified, the value of this field must be a label-style identifier, with an optional prefix,
                              e.g. "internal-vip" or "example.com/internal-vip". Unprefixed names are reserved for end-users.
                              This field can only be set when the Service type is 'LoadBalancer'. If not set, the default load
                              balancer implementation is used, today this is typically done through the cloud provider integration,
                              but should apply for any default implementation. If set, it is assumed that a load balancer
                              implementation is watching for Services with a matching class. Any default load balancer
                              implementation (e.g. cloud providers) should ignore Services that set this field.
                              This field can only be set when creating or updating a Service to type 'LoadBalancer'.
                              Once set, it can not be changed. This field will be wiped when a service is updated to a non 'LoadBalancer' type.
                            type: string
                          loadBalancerIP:
                            description: |-
                              Only applies to Service Type: LoadBalancer.
                              This feature depends on whether the underlying cloud-provider supports specifying
                              the loadBalancerIP when a load balancer is created.
                              This field will be ignored if the cloud-provider does not support the feature.
                              Deprecated: This field was under-specified and its meaning varies across implementations.
                              Using it is non-portable and it may not support dual-stack.
                              Users are encouraged to use implementation-specific annotations when available.
                            type: string
                          loadBalancerSourceRanges:
                            description: |-
                              If specified and supported by the platform, this will restrict traffic through the cloud-provider
                              load-balancer will be restricted to the specified client IPs. This field will be ignored if the
                              cloud-provider does not support the feature."
                              More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/
                            items:
                              type: string
                            type: array
                            x-kubernetes-list-type: atomic
                          ports:
                            description: |-
                              The list of ports that are exposed by this service.
                              More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
                            items:
                              description: ServicePort contains information on service's
                                port.
                              properties:
                                appProtocol:
                                  description: |-
                                    The application protocol for this port.
                                    This is used as a hint for implementations to offer richer behavior for protocols that they understand.
                                    This field follows standard Kubernetes label syntax.
                                    Valid values are either:

                                    * Un-prefixed protocol names - reserved for IANA standard service names (as per
                                    RFC-6335 and https://www.iana.org/assignments/service-names).

                                    * Kubernetes-defined prefixed names:
                                      * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext as described in https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-
                                      * 'kubernetes.io/ws'  - WebSocket over cleartext as described in https://www.rfc-editor.org/rfc/rfc6455
                                      * 'kubernetes.io/wss' - WebSocket over TLS as described in https://www.rfc-editor.org/rfc/rfc6455

                                    * Other protocols should use implementation-defined prefixed names such as
                                    mycompany.com/my-custom-protocol.
                                  type: string
                                name:
                                  description: |-
                                    The name of this port within the service. This must be a DNS_LABEL.
                                    All ports within a ServiceSpec must have unique names. When considering
                                    the endpoints for a Service, this must match the 'name' field in the
                                    EndpointPort.
                                    Optional if only one ServicePort is defined on this service.
                                  type: string
                                nodePort:
                                  description: |-
                                    The port on each node on which this service is exposed when type is
                                    NodePort or LoadBalancer.  Usually assigned by the system. If a value is
                                    specified, in-range, and not in use it will be used, otherwise the
                                    operation will fail.  If not specified, a port will be allocated if this
                                    Service requires one.  If this field is specified when creating a
                                    Service which does not need it, creation will fail. This field will be
                                    wiped when updating a Service to no longer need it (e.g. changing type
                                    from NodePort to ClusterIP).
                                    More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport
                                  format: int32
                                  type: integer
                                port:
                                  description: The port that will be exposed by this
                                    service.
                                  format: int32
                                  type: integer
                                protocol:
                                  default: TCP
                                  description: |-
                                    The IP protocol for this port. Supports "TCP", "UDP", and "SCTP".
                                    Default is TCP.
                                  type: string
                                targetPort:
                                  anyOf:
                                  - type: integer
                                  - type: string
                                  description: |-
                                    Number or name of the port to access on the pods targeted by the service.
                                    Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
                                    If this is a string, it will be looked up as a named port in the
                                    target Pod's container ports. If this is not specified, the value
                                    of the 'port' field is used (an identity map).
                                    This field is ignored for services with clusterIP=None, and should be
                                    omitted or set equal to the 'port' field.
                                    More info: https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service
                                  x-kubernetes-int-or-string: true
                              required:
                              - port
                              type: object
                            type: array
                            x-kubernetes-list-map-keys:
                            - port
                            - protocol
                            x-kubernetes-list-type: map
                          publishNotReadyAddresses:
                            description: |-
                              publishNotReadyAddresses indicates that any agent which deals with endpoints for this
                              Service should disregard any indications of ready/not-ready.
                              The primary use case for setting this field is for a StatefulSet's Headless Service to
                              propagate SRV DNS records for its Pods for the purpose of peer discovery.
                              The Kubernetes controllers that generate Endpoints and EndpointSlice resources for
                              Services interpret this to mean that all endpoints are considered "ready" even if the
                              Pods themselves are not. Agents which consume only Kubernetes generated endpoints
                              through the Endpoints or EndpointSlice resources can safely assume this behavior.
                            type: boolean
                          selector:
                            additionalProperties:
                              type: string
                            description: |-
                              Route service traffic to pods with label keys and values matching this
                              selector. If empty or not present, the service is assumed to have an
                              external process managing its endpoints, which Kubernetes will not
                              modify. Only applies to types ClusterIP, NodePort, and LoadBalancer.
                              Ignored if type is ExternalName.
                              More info: https://kubernetes.io/docs/concepts/services-networking/service/
                            type: object
                            x-kubernetes-map-type: atomic
                          sessionAffinity:
                            description: |-
                              Supports "ClientIP" and "None". Used to maintain session affinity.
                              Enable client IP based session affinity.
                              Must be ClientIP or None.
                              Defaults to None.
                              More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
                            type: string
                          sessionAffinityConfig:
                            description: sessionAffinityConfig contains the configurations
                              of session affinity.
                            properties:
                              clientIP:
                                description: clientIP contains the configurations
                                  of Client IP based session affinity.
                                properties:
                                  timeoutSeconds:
                                    description: |-
                                      timeoutSeconds specifies the seconds of ClientIP type session sticky time.
                                      The value must be >0 && <=86400(for 1 day) if ServiceAffinity == "ClientIP".
                                      Default value is 10800(for 3 hours).
                                    format: int32
                                    type: integer
                                type: object
                            type: object
                          trafficDistribution:
                            description: |-
                              TrafficDistribution offers a way to express preferences for how traffic is
                              distributed to Service endpoints. Implementations can use this field as a
                              hint, but are not required to guarantee strict adherence. If the field is
                              not set, the implementation will apply its default routing strategy. If set
                              to "PreferClose", implementations should prioritize endpoints that are
                              topologically close (e.g., same zone).
                              This is an alpha field and requires enabling ServiceTrafficDistribution feature.
                            type: string
                          type:
                            description: |-
                              type determines how the Service is exposed. Defaults to ClusterIP. Valid
                              options are ExternalName, ClusterIP, NodePort, and LoadBalancer.
                              "ClusterIP" allocates a cluster-internal IP address for load-balancing
                              to endpoints. Endpoints are determined by the selector or if that is not
                              specified, by manual construction of an Endpoints object or
                              EndpointSlice objects. If clusterIP is "None", no virtual IP is
                              allocated and the endpoints are published as a set of endpoints rather
                              than a virtual IP.
                              "NodePort" builds on ClusterIP and allocates a port on every node which
                              routes to the same endpoints as the clusterIP.
                              "LoadBalancer" builds on NodePort and creates an external load-balancer
                              (if supported in the current cloud) which routes to the same endpoints
                              as the clusterIP.
                              "ExternalName" aliases this service to the specified externalName.
                              Several other fields do not apply to ExternalName services.
                              More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
                            type: string
                        type: object
                    type: object
                  statefulSet:
                    description: Override configuration for the RabbitMQ StatefulSet.
                    type: object
                    x-kubernetes-preserve-unknown-fields: true
                type: object
              persistence:
                default:
                  storage: 10Gi
                description: The desired persistent storage configuration for each
                  Pod in the cluster.
                properties:
                  storage:
                    anyOf:
                    - type: integer
                    - type: string
                    default: 10Gi
                    description: |-
                      The requested size of the persistent volume attached to each Pod in the RabbitmqCluster.
                      The format of this field matches that defined by kubernetes/apimachinery.
                      See https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity for more info on the format of this field.
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    x-kubernetes-int-or-string: true
                  storageClassName:
                    description: The name of the StorageClass to claim a PersistentVolume
                      from.
                    type: string
                type: object
              podOverride:
                description: |-
                  PodOverride - Override configuration for per-pod services. When specified, individual LoadBalancer
                  services will be created for each pod with the provided configuration, and the transport URL will be
                  configured to use these per-pod services.
                properties:
                  services:
                    description: Services - list of per-pod service overrides
                    items:
                      description: |-
                        OverrideSpec - service override configuration for the Service created to serve traffic to the cluster.
                        Allows for the manifest of the created Service to be overwritten with custom configuration.
                      properties:
                        metadata:
                          description: |-
                            EmbeddedLabelsAnnotations is an embedded subset of the fields included in k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta.
                            Only labels and annotations are included.
                          properties:
                            annotations:
                              additionalProperties:
                                type: string
                              description: |-
                                Annotations is an unstructured key value map stored with a resource that may be
                                set by external tools to store and retrieve arbitrary metadata. They are not
                                queryable and should be preserved when modifying objects.
                                More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/
                              type: object
                            labels:
                              additionalProperties:
                                type: string
                              description: |-
                                Map of string keys and values that can be used to organize and categorize
                                (scope and select) objects. May match selectors of replication controllers
                                and services.
                                More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
                              type: object
                          type: object
                        spec:
                          description: |-
                            OverrideServiceSpec is a subset of the fields included in https://pkg.go.dev/k8s.io/api@v0.26.6/core/v1#ServiceSpec
                            Limited to Type, SessionAffinity, LoadBalancerSourceRanges, ExternalName, ExternalTrafficPolicy, SessionAffinityConfig,
                            IPFamilyPolicy, LoadBalancerClass and InternalTrafficPolicy
                          properties:
                            externalName:
                              description: |-
                                externalName is the external reference that discovery mechanisms will
                                return as an alias for this service (e.g. a DNS CNAME record). No
                                proxying will be involved.  Must be a lowercase RFC-1123 hostname
                                (https://tools.ietf.org/html/rfc1123) and requires `type` to be "ExternalName".
                              type: string
                            externalTrafficPolicy:
                              description: |-
                                externalTrafficPolicy describes how nodes distribute service traffic they
                                receive on one of the Service's "externally-facing" addresses (NodePorts,
                                ExternalIPs, and LoadBalancer IPs). If set to "Local", the proxy will configure
                                the service in a way that assumes that external load balancers will take care
                                of balancing the service traffic between nodes, and so each node will deliver
                                traffic only to the node-local endpoints of the service, without masquerading
                                the client source IP. (Traffic mistakenly sent to a node with no endpoints will
                                be dropped.) The default value, "Cluster", uses the standard behavior of
                                routing to all endpoints evenly (possibly modified by topology and other
                                features). Note that traffic sent to an External IP or LoadBalancer IP from
                                within the cluster will always get "Cluster" semantics, but clients sending to
                                a NodePort from within the cluster may need to take traffic policy into account
                                when picking a node.
                              type: string
                            internalTrafficPolicy:
                              description: |-
                                InternalTrafficPolicy describes how nodes distribute service traffic they
                                receive on the ClusterIP. If set to "Local", the proxy will assume that pods
                                only want to talk to endpoints of the service on the same node as the pod,
                                dropping the traffic if there are no local endpoints. The default value,
                                "Cluster", uses the standard behavior of routing to all endpoints evenly
                                (possibly modified by topology and other features).
                              type: string
                            ipFamilyPolicy:
                              description: |-
                                IPFamilyPolicy represents the dual-stack-ness requested or required by
                                this Service. If there is no value provided, then this field will be set
                                to SingleStack. Services can be "SingleStack" (a single IP family),
                                "PreferDualStack" (two IP families on dual-stack configured clusters or
                                a single IP family on single-stack clusters), or "RequireDualStack"
                                (two IP families on dual-stack configured clusters, otherwise fail). The
                                ipFamilies and clusterIPs fields depend on the value of this field. This
                                field will be wiped when updating a service to type ExternalName.
                              type: string
                            loadBalancerClass:
                              description: |-
                                loadBalancerClass is the class of the load balancer implementation this Service belongs to.
                                If specified, the value of this field must be a label-style identifier, with an optional prefix,
                                e.g. "internal-vip" or "example.com/internal-vip". Unprefixed names are reserved for end-users.
                                This field can only be set when the Service type is 'LoadBalancer'. If not set, the default load
                                balancer implementation is used, today this is typically done through the cloud provider integration,
                                but should apply for any default implementation. If set, it is assumed that a load balancer
                                implementation is watching for Services with a matching class. Any default load balancer
                                implementation (e.g. cloud providers) should ignore Services that set this field.
                                This field can only be set when creating or updating a Service to type 'LoadBalancer'.
                                Once set, it can not be changed. This field will be wiped when a service is updated to a non 'LoadBalancer' type.
                              type: string
                            loadBalancerSourceRanges:
                              description: |-
                                If specified and supported by the platform, this will restrict traffic through the cloud-provider
                                load-balancer will be restricted to the specified client IPs. This field will be ignored if the
                                cloud-provider does not support the feature."
                                More info: https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/
                              items:
                                type: string
                              type: array
                              x-kubernetes-list-type: atomic
                            sessionAffinity:
                              description: |-
                                Supports "ClientIP" and "None". Used to maintain session affinity.
                                Enable client IP based session affinity.
                                Must be ClientIP or None.
                                Defaults to None.
                                More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
                              type: string
                            sessionAffinityConfig:
                              description: sessionAffinityConfig contains the configurations
                                of session affinity.
                              properties:
                                clientIP:
                                  description: clientIP contains the configurations
                                    of Client IP based session affinity.
                                  properties:
                                    timeoutSeconds:
                                      description: |-
                                        timeoutSeconds specifies the seconds of ClientIP type session sticky time.
                                        The value must be >0 && <=86400(for 1 day) if ServiceAffinity == "ClientIP".
                                        Default value is 10800(for 3 hours).
                                      format: int32
                                      type: integer
                                  type: object
                              type: object
                            type:
                              description: |-
                                type determines how the Service is exposed. Defaults to ClusterIP. Valid
                                options are ExternalName, ClusterIP, NodePort, and LoadBalancer.
                                "ClusterIP" allocates a cluster-internal IP address for load-balancing
                                to endpoints. Endpoints are determined by the selector or if that is not
                                specified, by manual construction of an Endpoints object or
                                EndpointSlice objects. If clusterIP is "None", no virtual IP is
                                allocated and the endpoints are published as a set of endpoints rather
                                than a virtual IP.
                                "NodePort" builds on ClusterIP and allocates a port on every node which
                                routes to the same endpoints as the clusterIP.
                                "LoadBalancer" builds on NodePort and creates an external load-balancer
                                (if supported in the current cloud) which routes to the same endpoints
                                as the clusterIP.
                                "ExternalName" aliases this service to the specified externalName.
                                Several other fields do not apply to ExternalName services.
                                More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
                              type: string
                          type: object
                      type: object
                    type: array
                    x-kubernetes-list-type: atomic
                type: object
              queueType:
                description: |-
                  QueueType to eventually apply the ha-all policy or configure default queue type for the cluster.
                  Allowed values are: None, Mirrored, Quorum. Defaults to Quorum if not specified.
                type: string
              rabbitmq:
                description: Configuration options for RabbitMQ Pods created in the
                  cluster.
                properties:
                  additionalConfig:
                    description: |-
                      Modify to add to the rabbitmq.conf file in addition to default configurations set by the operator.
                      Modifying this property on an existing RabbitmqCluster will trigger a StatefulSet rolling restart and will cause rabbitmq downtime.
                      For more information on this config, see https://www.rabbitmq.com/configure.html#config-file
                    maxLength: 100000
                    type: string
                  additionalPlugins:
                    description: 'List of plugins to enable in addition to essential
                      plugins: rabbitmq_management, rabbitmq_prometheus, and rabbitmq_peer_discovery_k8s.'
                    items:
                      description: A Plugin to enable on the RabbitmqCluster.
                      maxLength: 100
                      pattern: ^\w+$
                      type: string
                    maxItems: 100
                    type: array
                  advancedConfig:
                    description: |-
                      Specify any rabbitmq advanced.config configurations to apply to the cluster.
                      For more information on advanced config, see https://www.rabbitmq.com/configure.html#advanced-config-file
                    maxLength: 100000
                    type: string
                  envConfig:
                    description: |-
                      Modify to add to the rabbitmq-env.conf file. Modifying this property on an existing RabbitmqCluster will trigger a StatefulSet rolling restart and will cause rabbitmq downtime.
                      For more information on env config, see https://www.rabbitmq.com/man/rabbitmq-env.conf.5.html
                    maxLength: 100000
                    type: string
                  erlangInetConfig:
                    description: |-
                      Erlang Inet configuration to apply to the Erlang VM running rabbit.
                      See also: https://www.erlang.org/doc/apps/erts/inet_cfg.html
                    maxLength: 2000
                    type: string
                type: object
              replicas:
                default: 1
                description: |-
                  Replicas is the number of nodes in the RabbitMQ cluster. Each node is deployed as a Replica in a StatefulSet. Only 1, 3, 5 replicas clusters are tested.
                  This value should be an odd number to ensure the resultant cluster can establish exactly one quorum of nodes
                  in the event of a fragmenting network partition.
                format: int32
                minimum: 0
                type: integer
              resources:
                default:
                  limits:
                    cpu: 2000m
                    memory: 2Gi
                  requests:
                    cpu: 1000m
                    memory: 2Gi
                description: The desired compute resource requirements of Pods in
                  the cluster.
                properties:
                  claims:
                    description: |-
                      Claims lists the names of resources, defined in spec.resourceClaims,
                      that are used by this container.

                      This is an alpha field and requires enabling the
                      DynamicResourceAllocation feature gate.

                      This field is immutable. It can only be set for containers.
                    items:
                      description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                      properties:
                        name:
                          description: |-
                            Name must match the name of one entry in pod.spec.resourceClaims of
                            the Pod where this field is used. It makes that resource available
                            inside a container.
                          type: string
                        request:
                          description: |-
                            Request is the name chosen for a request in the referenced claim.
                            If empty, everything from the claim is made available, otherwise
                            only the result of this request.
                          type: string
                      required:
                      - name
                      type: object
                    type: array
                    x-kubernetes-list-map-keys:
                    - name
                    x-kubernetes-list-type: map
                  limits:
                    additionalProperties:
                      anyOf:
                      - type: integer
                      - type: string
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      x-kubernetes-int-or-string: true
                    description: |-
                      Limits describes the maximum amount of compute resources allowed.
                      More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                    type: object
                  requests:
                    additionalProperties:
                      anyOf:
                      - type: integer
                      - type: string
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      x-kubernetes-int-or-string: true
                    description: |-
                      Requests describes the minimum amount of compute resources required.
                      If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                      otherwise to an implementation-defined value. Requests cannot exceed Limits.
                      More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                    type: object
                type: object
              secretBackend:
                description: |-
                  Secret backend configuration for the RabbitmqCluster.
                  Enables to fetch default user credentials and certificates from K8s external secret stores.
                properties:
                  externalSecret:
                    description: |-
                      LocalObjectReference contains enough information to let you locate the
                      referenced object inside the same namespace.
                    properties:
                      name:
                        default: ""
                        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/working-with-objects/names/#names
                        type: string
                    type: object
                    x-kubernetes-map-type: atomic
                  vault:
                    description: |-
                      VaultSpec will add Vault annotations (see https://www.vaultproject.io/docs/platform/k8s/injector/annotations)
                      to RabbitMQ Pods. It requires a Vault Agent Sidecar Injector (https://www.vaultproject.io/docs/platform/k8s/injector)
                      to be installed in the K8s cluster. The injector is a K8s Mutation Webhook Controller that alters RabbitMQ Pod specifications
                      (based on the added Vault annotations) to include Vault Agent containers that render Vault secrets to the volume.
                    properties:
                      annotations:
                        additionalProperties:
                          type: string
                        description: |-
                          Vault annotations that override the Vault annotations set by the cluster-operator.
                          For a list of valid Vault annotations, see https://www.vaultproject.io/docs/platform/k8s/injector/annotations
                        type: object
                      defaultUserPath:
                        description: |-
                          Path in Vault to access a KV (Key-Value) secret with the fields username and password for the default user.
                          For example "secret/data/rabbitmq/config".
                        type: string
                      defaultUserUpdaterImage:
                        description: |-
                          Sidecar container that updates the default user's password in RabbitMQ when it changes in Vault.
                          Additionally, it updates /var/lib/rabbitmq/.rabbitmqadmin.conf (used by rabbitmqadmin CLI).
                          Set to empty string to disable the sidecar container.
                        type: string
                      role:
                        description: |-
                          Role in Vault.
                          If vault.defaultUserPath is set, this role must have capability to read the pre-created default user credential in Vault.
                          If vault.tls is set, this role must have capability to create and update certificates in the Vault PKI engine for the domains
                          "<namespace>" and "<namespace>.svc".
                        type: string
                      tls:
                        properties:
                          altNames:
                            description: |-
                              Specifies the requested Subject Alternative Names (SANs), in a comma-delimited list.
                              These will be appended to the SANs added by the cluster-operator.
                              The cluster-operator will add SANs:
                              "<RabbitmqCluster name>-server-<index>.<RabbitmqCluster name>-nodes.<namespace>" for each pod,
                              e.g. "myrabbit-server-0.myrabbit-nodes.default".
                            type: string
                          commonName:
                            description: |-
                              Specifies the requested certificate Common Name (CN).
                              Defaults to <serviceName>.<namespace>.svc if not provided.
                            type: string
                          ipSans:
                            description: Specifies the requested IP Subject Alternative
                              Names, in a comma-delimited list.
                            type: string
                          pkiIssuerPath:
                            description: |-
                              Path in Vault PKI engine.
                              For example "pki/issue/hashicorp-com".
                              required
                            type: string
                          pkiRootPath:
                            description: Specifies an optional path to retrieve the
                              root CA from vault.  Useful if certificates are issued
                              by an intermediate CA
                            type: string
                        type: object
                    type: object
                type: object
              service:
                description: Settable attributes for the Service resource.
                properties:
                  annotations:
                    additionalProperties:
                      type: string
                    description: Annotations to add to the Service.
                    type: object
                  ipFamilyPolicy:
                    description: |-
                      IPFamilyPolicy represents the dual-stack-ness requested or required by a Service
                      See also: https://pkg.go.dev/k8s.io/api/core/v1#IPFamilyPolicy
                    enum:
                    - SingleStack
                    - PreferDualStack
                    - RequireDualStack
                    type: string
                  labels:
                    additionalProperties:
                      type: string
                    type: object
                  type:
                    default: ClusterIP
                    description: |-
                      Type of Service to create for the cluster. Must be one of: ClusterIP, LoadBalancer, NodePort.
                      For more info see https://pkg.go.dev/k8s.io/api/core/v1#ServiceType
                    enum:
                    - ClusterIP
                    - LoadBalancer
                    - NodePort
                    type: string
                type: object
              skipPostDeploySteps:
                description: |-
                  If unset, or set to false, the cluster will run `rabbitmq-queues rebalance all` whenever the cluster is updated.
                  Set to true to prevent the operator rebalancing queue leaders after a cluster update.
                  Has no effect if the cluster only consists of one node.
                  For more information, see https://www.rabbitmq.com/rabbitmq-queues.8.html#rebalance
                type: boolean
              terminationGracePeriodSeconds:
                default: 604800
                description: |-
                  TerminationGracePeriodSeconds is the timeout that each rabbitmqcluster pod will have to terminate gracefully.
                  It defaults to 604800 seconds ( a week long) to ensure that the container preStop lifecycle hook can finish running.
                  For more information, see: https://github.com/rabbitmq/cluster-operator/blob/main/docs/design/20200520-graceful-pod-termination.md
                format: int64
                minimum: 0
                type: integer
              tls:
                description: TLS-related configuration for the RabbitMQ cluster.
                properties:
                  caSecretName:
                    description: |-
                      Name of a Secret in the same Namespace as the RabbitmqCluster, containing the Certificate Authority's public certificate for TLS.
                      The Secret must store this as ca.crt.
                      This Secret can be created by running `kubectl create secret generic ca-secret --from-file=ca.crt=path/to/ca.crt`
                      Used for mTLS, and TLS for rabbitmq_web_stomp and rabbitmq_web_mqtt.
                    type: string
                  disableNonTLSListeners:
                    description: |-
                      When set to true, the RabbitmqCluster disables non-TLS listeners for RabbitMQ, management plugin and for any enabled plugins in the following list: stomp, mqtt, web_stomp, web_mqtt.
                      Only TLS-enabled clients will be able to connect.
                    type: boolean
                  secretName:
                    description: |-
                      Name of a Secret in the same Namespace as the RabbitmqCluster, containing the server's private key & public certificate for TLS.
                      The Secret must store these as tls.key and tls.crt, respectively.
                      This Secret can be created by running `kubectl create secret tls tls-secret --cert=path/to/tls.crt --key=path/to/tls.key`
                    type: string
                type: object
              tolerations:
                description: Tolerations is the list of Toleration resources attached
                  to each Pod in the RabbitmqCluster.
                items:
                  description: |-
                    The pod this Toleration is attached to tolerates any taint that matches
                    the triple <key,value,effect> using the matching operator <operator>.
                  properties:
                    effect:
                      description: |-
                        Effect indicates the taint effect to match. Empty means match all taint effects.
                        When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
                      type: string
                    key:
                      description: |-
                        Key is the taint key that the toleration applies to. Empty means match all taint keys.
                        If the key is empty, operator must be Exists; this combination means to match all values and all keys.
                      type: string
                    operator:
                      description: |-
                        Operator represents a key's relationship to the value.
                        Valid operators are Exists and Equal. Defaults to Equal.
                        Exists is equivalent to wildcard for value, so that a pod can
                        tolerate all taints of a particular category.
                      type: string
                    tolerationSeconds:
                      description: |-
                        TolerationSeconds represents the period of time the toleration (which must be
                        of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
                        it is not set, which means tolerate the taint forever (do not evict). Zero and
                        negative values will be treated as 0 (evict immediately) by the system.
                      format: int64
                      type: integer
                    value:
                      description: |-
                        Value is the taint value the toleration matches to.
                        If the operator is Exists, the value should be empty, otherwise just a regular string.
                      type: string
                  type: object
                type: array
              topologyRef:
                description: |-
                  TopologyRef to apply the Topology defined by the associated CR referenced
                  by name
                properties:
                  name:
                    description: Name - The Topology CR name that the Service references
                    type: string
                  namespace:
                    description: |-
                      Namespace - The Namespace to fetch the Topology CR referenced
                      NOTE: Namespace currently points by default to the same namespace where
                      the Service is deployed. Customizing the namespace is not supported and
                      webhooks prevent editing this field to a value different from the
                      current project
                    type: string
                type: object
            required:
            - containerImage
            type: object
          status:
            description: RabbitMqStatus defines the observed state of RabbitMq
            properties:
              conditions:
                description: Conditions
                items:
                  description: Condition defines an observation of a API resource
                    operational state.
                  properties:
                    lastTransitionTime:
                      description: |-
                        Last time the condition transitioned from one status to another.
                        This should be when the underlying condition changed. If that is not known, then using the time when
                        the API field changed is acceptable.
                      format: date-time
                      type: string
                    message:
                      description: A human readable message indicating details about
                        the transition.
                      type: string
                    reason:
                      description: The reason for the condition's last transition
                        in CamelCase.
                      type: string
                    severity:
                      description: |-
                        Severity provides a classification of Reason code, so the current situation is immediately
                        understandable and could act accordingly.
                        It is meant for situations where Status=False and it should be indicated if it is just
                        informational, warning (next reconciliation might fix it) or an error (e.g. DB create issue
                        and no actions to automatically resolve the issue can/should be done).
                        For conditions where Status=Unknown or Status=True the Severity should be SeverityNone.
                      type: string
                    status:
                      description: Status of the condition, one of True, False, Unknown.
                      type: string
                    type:
                      description: Type of condition in CamelCase.
                      type: string
                  required:
                  - lastTransitionTime
                  - status
                  - type
                  type: object
                type: array
              lastAppliedTopology:
                description: LastAppliedTopology - the last applied Topology
                properties:
                  name:
                    description: Name - The Topology CR name that the Service references
                    type: string
                  namespace:
                    description: |-
                      Namespace - The Namespace to fetch the Topology CR referenced
                      NOTE: Namespace currently points by default to the same namespace where
                      the Service is deployed. Customizing the namespace is not supported and
                      webhooks prevent editing this field to a value different from the
                      current project
                    type: string
                type: object
              observedGeneration:
                description: |-
                  ObservedGeneration - the most recent generation observed for this
                  service. If the observed generation is less than the spec generation,
                  then the controller has not processed the latest changes injected by
                  the opentack-operator in the top-level CR (e.g. the ContainerImage)
                format: int64
                type: integer
              queueType:
                description: QueueType - store whether default ha-all policy is present
                  or not
                type: string
              serviceHostnames:
                description: |-
                  ServiceHostnames - list of per-pod service hostnames for RabbitMQ cluster.
                  When populated, transport URLs use these hostnames instead of pod names.
                items:
                  type: string
                type: array
                x-kubernetes-list-type: atomic
            type: object
        type: object
    served: true
    storage: true
    subresources:
      status: {}
status:
  acceptedNames:
    categories:
    - all
    - rabbitmq
    kind: RabbitMq
    listKind: RabbitMqList
    plural: rabbitmqs
    singular: rabbitmq
  conditions:
  - lastTransitionTime: "2026-04-06T12:15:08Z"
    message: no conflicts found
    reason: NoConflicts
    status: "True"
    type: NamesAccepted
  - lastTransitionTime: "2026-04-06T12:15:08Z"
    message: the initial names have been accepted
    reason: InitialNamesAccepted
    status: "True"
    type: Established
  storedVersions:
  - v1beta1
