---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    config.couchbase.com/version: 2.3.0
    controller-gen.kubebuilder.io/version: v0.8.0
  name: couchbaseclusters.couchbase.com
spec:
  group: couchbase.com
  names:
    kind: CouchbaseCluster
    listKind: CouchbaseClusterList
    plural: couchbaseclusters
    shortNames:
    - cbc
    singular: couchbasecluster
  scope: Namespaced
  versions:
  - additionalPrinterColumns:
    - jsonPath: .status.currentVersion
      name: version
      type: string
    - jsonPath: .status.size
      name: size
      type: string
    - jsonPath: .status.conditions[?(@.type=="Available")].reason
      name: status
      type: string
    - jsonPath: .status.clusterId
      name: uuid
      type: string
    - jsonPath: .metadata.creationTimestamp
      name: age
      type: date
    name: v2
    schema:
      openAPIV3Schema:
        description: The CouchbaseCluster resource represents a Couchbase cluster.  It
          allows configuration of cluster topology, networking, storage and security
          options.
        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: ClusterSpec is the specification for a CouchbaseCluster resources,
              and allows the cluster to be customized.
            properties:
              antiAffinity:
                description: AntiAffinity forces the Operator to schedule different
                  Couchbase server pods on different Kubernetes nodes.  Anti-affinity
                  reduces the likelihood of unrecoverable failure in the event of
                  a node issue.  Use of anti-affinity is highly recommended for production
                  clusters.
                type: boolean
              autoResourceAllocation:
                description: AutoResourceAllocation populates pod resource requests
                  based on the services running on that pod.  When enabled, this feature
                  will calculate the memory request as the total of service allocations
                  defined in `spec.cluster`, plus an overhead defined by `spec.autoResourceAllocation.overheadPercent`.Changing
                  individual allocations for a service will cause a cluster upgrade
                  as allocations are modified in the underlying pods.  This field
                  also allows default pod CPU requests and limits to be applied. All
                  resource allocations can be overridden by explicitly configuring
                  them in the `spec.servers.resources` field.
                properties:
                  cpuLimits:
                    anyOf:
                    - type: integer
                    - type: string
                    default: "4"
                    description: 'CPULimits automatically populates the CPU limits
                      across all Couchbase server pods.  This field defaults to "4"
                      CPUs.  Explicitly specifying the CPU limit for a particular
                      server class will override this value.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    type: string
                    x-kubernetes-int-or-string: true
                  cpuRequests:
                    anyOf:
                    - type: integer
                    - type: string
                    default: "2"
                    description: 'CPURequests automatically populates the CPU requests
                      across all Couchbase server pods.  The default value of "2",
                      is the minimum recommended number of CPUs required to run Couchbase
                      Server.  Explicitly specifying the CPU request for a particular
                      server class will override this value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    type: string
                    x-kubernetes-int-or-string: true
                  enabled:
                    description: Enabled defines whether auto-resource allocation
                      is enabled.
                    type: boolean
                  overheadPercent:
                    default: 25
                    description: OverheadPercent defines the amount of memory above
                      that required for individual services on a pod.  For Couchbase
                      Server this should be approximately 25%.
                    minimum: 0
                    type: integer
                type: object
              autoscaleStabilizationPeriod:
                description: "AutoscaleStabilizationPeriod defines how long after
                  a rebalance the corresponding HorizontalPodAutoscaler should remain
                  in maintenance mode. During maintenance mode all autoscaling is
                  disabled since every HorizontalPodAutoscaler associated with the
                  cluster becomes inactive. Since certain metrics can be unpredictable
                  when Couchbase is rebalancing or upgrading, setting a stabilization
                  period helps to prevent scaling recommendations from the HorizontalPodAutoscaler
                  for a provided period of time. \n Values must be a valid Kubernetes
                  duration of 0s or higher: https://golang.org/pkg/time/#ParseDuration
                  A value of 0, puts the cluster in maintenance mode during rebalance
                  but immediately exits this mode once the rebalance has completed.
                  When undefined, the HPA is never put into maintenance mode during
                  rebalance."
                type: string
              backup:
                description: Backup defines whether the Operator should manage automated
                  backups, and how to lookup backup resources.
                properties:
                  image:
                    description: The Backup Image to run on backup pods.
                    type: string
                  imagePullSecrets:
                    description: ImagePullSecrets allow you to use an image from private
                      repositories and non-dockerhub ones.
                    items:
                      description: LocalObjectReference contains enough information
                        to let you locate the referenced object inside the same namespace.
                      properties:
                        name:
                          description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                            TODO: Add other useful fields. apiVersion, kind, uid?'
                          type: string
                      type: object
                    type: array
                  managed:
                    description: Managed defines whether backups are managed by us
                      or the clients.
                    type: boolean
                  nodeSelector:
                    additionalProperties:
                      type: string
                    description: NodeSelector defines which nodes to constrain the
                      pods that run any backup and restore operations to.
                    type: object
                  objectEndpoint:
                    description: ObjectEndpoint contains the configuration for connecting
                      to a custom S3 compliant object store.
                    properties:
                      secret:
                        description: The name of the secret, in this namespace, that
                          contains the CA certificate for verification of a TLS endpoint
                          (when required, e.g. not signed by a public CA). The secret
                          must have the key with the name "tls.crt"
                        type: string
                      url:
                        description: The host/address of the custom object endpoint.
                        type: string
                      useVirtualPath:
                        description: UseVirtualPath will force the AWS SDK to use
                          the new virtual style paths. by default alternative path
                          style URLs which are often required by S3 compatible object
                          stores.
                        type: boolean
                    type: object
                  resources:
                    description: Resources is the resource requirements for the backup
                      and restore containers.  Will be populated by defaults if not
                      specified.
                    properties:
                      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. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                        type: object
                    type: object
                  s3Secret:
                    description: S3Secret contains the region and credentials for
                      operating backups in S3. This field must be popluated when the
                      `spec.s3bucket` field is specified for a backup or restore resource.
                    type: string
                  selector:
                    description: Selector allows CouchbaseBackup and CouchbaseBackupRestore
                      resources to be filtered based on labels.
                    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
                          required:
                          - key
                          - operator
                          type: object
                        type: array
                      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
                  serviceAccountName:
                    default: couchbase-backup
                    description: The Service Account to run backup (and restore) pods
                      under. Without this backup pods will not be able to update status.
                    type: string
                  tolerations:
                    description: Tolerations specifies all backup and restore pod
                      tolerations.
                    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
                  useIAMRole:
                    description: UseIAMRole enables backup to fetch EC2 instance metadata.
                      This allows the AWS SDK to use the EC2's IAM Role for S3 access.
                      UseIAMRole will ignore credentials in s3Secret.
                    type: boolean
                required:
                - image
                type: object
              buckets:
                description: Buckets defines whether the Operator should manage buckets,
                  and how to lookup bucket resources.
                properties:
                  managed:
                    description: Managed defines whether buckets are managed by the
                      Operator (true), or user managed (false). When Operator managed,
                      all buckets must be defined with either CouchbaseBucket, CouchbaseEphemeralBucket
                      or CouchbaseMemcachedBucket resources.  Manual addition of buckets
                      will be reverted by the Operator.  When user managed, the Operator
                      will not interrogate buckets at all.  This field defaults to
                      false.
                    type: boolean
                  selector:
                    description: Selector is a label selector used to list buckets
                      in the namespace that are managed by the Operator.
                    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
                          required:
                          - key
                          - operator
                          type: object
                        type: array
                      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
                  synchronize:
                    description: Synchronize allows unmanaged buckets, scopes, and
                      collections to be synchronized as Kubernetes resources by the
                      Operator.  This feature is intended for development only and
                      should not be used for production workloads.  The synchronization
                      workflow starts with `spec.buckets.managed` being set to false,
                      the user can manually create buckets, scopes, and collections
                      using the Couchbase UI, or other tooling.  When you wish to
                      commit to Kubernetes resources, you must specify a unique label
                      selector in the `spec.buckets.selector` field, and this field
                      is set to true.  The Operator will create Kubernetes resources
                      for you, and upon completion set the cluster's `Synchronized`
                      status condition.  You may then safely set `spec.buckets.managed`
                      to true and the Operator will manage these resources as per
                      usual.  To update an already managed data topology, you must
                      first set it to unmanaged, make any changes, and delete any
                      old resources, then follow the standard synchronization workflow.  The
                      Operator can not, and will not, ever delete, or make modifications
                      to resource specifications that are intended to be user managed,
                      or managed by a life cycle management tool. These actions must
                      be instigated by an end user.  For a more complete experience,
                      refer to the documentation for the `cao save` and `cao restore`
                      CLI commands.
                    type: boolean
                type: object
              cluster:
                default: {}
                description: ClusterSettings define Couchbase cluster-wide settings
                  such as memory allocation, failover characteristics and index settings.
                properties:
                  analyticsServiceMemoryQuota:
                    anyOf:
                    - type: integer
                    - type: string
                    default: 1Gi
                    description: 'AnalyticsServiceMemQuota is the amount of memory
                      that should be allocated to the analytics service. This value
                      is per-pod, and only applicable to pods belonging to server
                      classes running the analytics service.  This field must be a
                      quantity greater than or equal to 1Gi.  This field defaults
                      to 1Gi.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    type: string
                    x-kubernetes-int-or-string: true
                  autoCompaction:
                    default: {}
                    description: AutoCompaction allows the configuration of auto-compaction,
                      including on what conditions disk space is reclaimed and when
                      it is allowed to run.
                    properties:
                      databaseFragmentationThreshold:
                        default: {}
                        description: DatabaseFragmentationThreshold defines triggers
                          for when database compaction should start.
                        properties:
                          percent:
                            default: 30
                            description: Percent is the percentage of disk fragmentation
                              after which to decompaction will be triggered. This
                              field must be in the range 2-100, defaulting to 30.
                            maximum: 100
                            minimum: 2
                            type: integer
                          size:
                            anyOf:
                            - type: integer
                            - type: string
                            description: 'Size is the amount of disk framentation,
                              that once exceeded, will trigger decompaction. More
                              info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                            type: string
                            x-kubernetes-int-or-string: true
                        type: object
                      parallelCompaction:
                        description: ParallelCompaction controls whether database
                          and view compactions can happen in parallel.
                        type: boolean
                      timeWindow:
                        description: TimeWindow allows restriction of when compaction
                          can occur.
                        properties:
                          abortCompactionOutsideWindow:
                            description: AbortCompactionOutsideWindow stops compaction
                              processes when the process moves outside the window.
                            type: boolean
                          end:
                            description: End is a wallclock time, in the form HH:MM,
                              when a compaction should stop.
                            pattern: ^(2[0-3]|[01]?[0-9]):([0-5]?[0-9])$
                            type: string
                          start:
                            description: Start is a wallclock time, in the form HH:MM,
                              when a compaction is permitted to start.
                            pattern: ^(2[0-3]|[01]?[0-9]):([0-5]?[0-9])$
                            type: string
                        type: object
                      tombstonePurgeInterval:
                        default: 72h
                        description: 'TombstonePurgeInterval controls how long to
                          wait before purging tombstones. This field must be in the
                          range 1h-1440h, defaulting to 72h. More info:  https://golang.org/pkg/time/#ParseDuration'
                        type: string
                      viewFragmentationThreshold:
                        default: {}
                        description: ViewFragmentationThreshold defines triggers for
                          when view compaction should start.
                        properties:
                          percent:
                            default: 30
                            description: Percent is the percentage of disk fragmentation
                              after which to decompaction will be triggered. This
                              field must be in the range 2-100, defaulting to 30.
                            maximum: 100
                            minimum: 2
                            type: integer
                          size:
                            anyOf:
                            - type: integer
                            - type: string
                            description: 'Size is the amount of disk framentation,
                              that once exceeded, will trigger decompaction. More
                              info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                            type: string
                            x-kubernetes-int-or-string: true
                        type: object
                    type: object
                  autoFailoverMaxCount:
                    default: 3
                    description: AutoFailoverMaxCount is the maximum number of automatic
                      failovers Couchbase server will allow before not allowing any
                      more.  This field must be between 1-3, default 3.
                    format: int64
                    maximum: 3
                    minimum: 1
                    type: integer
                  autoFailoverOnDataDiskIssues:
                    description: AutoFailoverOnDataDiskIssues defines whether Couchbase
                      server should failover a pod if a disk issue was detected.
                    type: boolean
                  autoFailoverOnDataDiskIssuesTimePeriod:
                    default: 120s
                    description: 'AutoFailoverOnDataDiskIssuesTimePeriod defines how
                      long to wait for transient errors before failing over a faulty
                      disk.  This field must be in the range 5-3600s, defaulting to
                      120s.  More info:  https://golang.org/pkg/time/#ParseDuration'
                    type: string
                  autoFailoverServerGroup:
                    description: AutoFailoverServerGroup whether to enable failing
                      over a server group.
                    type: boolean
                  autoFailoverTimeout:
                    default: 120s
                    description: 'AutoFailoverTimeout defines how long Couchbase server
                      will wait between a pod being witnessed as down, until when
                      it will failover the pod.  Couchbase server will only failover
                      pods if it deems it safe to do so, and not result in data loss.  This
                      field must be in the range 5-3600s, defaulting to 120s. More
                      info:  https://golang.org/pkg/time/#ParseDuration'
                    type: string
                  clusterName:
                    description: ClusterName defines the name of the cluster, as displayed
                      in the Couchbase UI. By default, the cluster name is that specified
                      in the CouchbaseCluster resource's metadata.
                    type: string
                  data:
                    description: Data allows the data service to be configured.
                    properties:
                      readerThreads:
                        description: ReaderThreads allows the number of threads used
                          by the data service, per pod, to be altered.  This value
                          must be between 4 and 64 threads, and should only be increased
                          where there are sufficient CPU resources allocated for their
                          use.  If not specified, this defaults to the default value
                          set by Couchbase Server.
                        maximum: 64
                        minimum: 4
                        type: integer
                      writerThreads:
                        description: ReaderThreads allows the number of threads used
                          by the data service, per pod, to be altered.  This setting
                          is especially relevant when using "durable writes", increasing
                          this field will have a large impact on performance.  This
                          value must be between 4 and 64 threads, and should only
                          be increased where there are sufficient CPU resources allocated
                          for their use. If not specified, this defaults to the default
                          value set by Couchbase Server.
                        maximum: 64
                        minimum: 4
                        type: integer
                    type: object
                  dataServiceMemoryQuota:
                    anyOf:
                    - type: integer
                    - type: string
                    default: 256Mi
                    description: 'DataServiceMemQuota is the amount of memory that
                      should be allocated to the data service. This value is per-pod,
                      and only applicable to pods belonging to server classes running
                      the data service.  This field must be a quantity greater than
                      or equal to 256Mi.  This field defaults to 256Mi.  More info:
                      https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    type: string
                    x-kubernetes-int-or-string: true
                  eventingServiceMemoryQuota:
                    anyOf:
                    - type: integer
                    - type: string
                    default: 256Mi
                    description: 'EventingServiceMemQuota is the amount of memory
                      that should be allocated to the eventing service. This value
                      is per-pod, and only applicable to pods belonging to server
                      classes running the eventing service.  This field must be a
                      quantity greater than or equal to 256Mi.  This field defaults
                      to 256Mi.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    type: string
                    x-kubernetes-int-or-string: true
                  indexServiceMemoryQuota:
                    anyOf:
                    - type: integer
                    - type: string
                    default: 256Mi
                    description: 'IndexServiceMemQuota is the amount of memory that
                      should be allocated to the index service. This value is per-pod,
                      and only applicable to pods belonging to server classes running
                      the index service.  This field must be a quantity greater than
                      or equal to 256Mi.  This field defaults to 256Mi.  More info:
                      https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    type: string
                    x-kubernetes-int-or-string: true
                  indexStorageSetting:
                    default: memory_optimized
                    description: DEPRECATED - by indexer. The index storage mode to
                      use for secondary indexing.  This field must be one of "memory_optimized"
                      or "plasma", defaulting to "memory_optimized".  This field is
                      immutable and cannot be changed unless there are no server classes
                      running the index service in the cluster.
                    enum:
                    - memory_optimized
                    - plasma
                    type: string
                  indexer:
                    description: Indexer allows the indexer to be configured.
                    properties:
                      logLevel:
                        default: info
                        description: LogLevel controls the verbosity of indexer logs.  This
                          field must be one of "silent", "fatal", "error", "warn",
                          "info", "verbose", "timing", "debug" or "trace", defaulting
                          to "info".
                        enum:
                        - silent
                        - fatal
                        - error
                        - warn
                        - info
                        - verbose
                        - timing
                        - debug
                        - trace
                        type: string
                      maxRollbackPoints:
                        default: 2
                        description: MaxRollbackPoints controls the number of checkpoints
                          that can be rolled back to.  The default is 2, with a minimum
                          of 1.
                        minimum: 1
                        type: integer
                      memorySnapshotInterval:
                        default: 200ms
                        description: MemorySnapshotInterval controls when memory indexes
                          should be snapshotted. This defaults to 200ms, and must
                          be greater than or equal to 1ms.
                        type: string
                      stableSnapshotInterval:
                        default: 5s
                        description: StableSnapshotInterval controls when disk indexes
                          should be snapshotted. This defaults to 5s, and must be
                          greater than or equal to 1ms.
                        type: string
                      storageMode:
                        default: memory_optimized
                        description: StorageMode controls the underlying storage engine
                          for indexes.  Once set it can only be modified if there
                          are no nodes in the cluster running the index service.  The
                          field must be one of "memory_optimized" or "plasma", defaulting
                          to "memory_optimized".
                        enum:
                        - memory_optimized
                        - plasma
                        type: string
                      threads:
                        description: Threads controls the number of processor threads
                          to use for indexing. A value of 0 means 1 per CPU.  This
                          attribute must be greater than or equal to 0, defaulting
                          to 0.
                        minimum: 0
                        type: integer
                    type: object
                  query:
                    description: Query allows the query service to be configured.
                    properties:
                      backfillEnabled:
                        default: true
                        description: BackfillEnabled allows the query service to backfill.
                        type: boolean
                      temporarySpace:
                        anyOf:
                        - type: integer
                        - type: string
                        default: 5Gi
                        description: 'TemporarySpace allows the temporary storage
                          used by the query service backfill, per-pod, to be modified.  This
                          field requires `backfillEnabled` to be set to true in order
                          to have any effect. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                        pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                        type: string
                        x-kubernetes-int-or-string: true
                      temporarySpaceUnlimited:
                        description: TemporarySpaceUnlimited allows the temporary
                          storage used by the query service backfill, per-pod, to
                          be unconstrained.  This field requires `backfillEnabled`
                          to be set to true in order to have any effect. This field
                          overrides `temporarySpace`.
                        type: boolean
                    type: object
                  queryServiceMemoryQuota:
                    anyOf:
                    - type: integer
                    - type: string
                    description: 'QueryServiceMemQuota is a dummy field.  By default,
                      Couchbase server provides no memory resource constraints for
                      the query service, so this has no effect on Couchbase server.  It
                      is, however, used when the spec.autoResourceAllocation feature
                      is enabled, and is used to define the amount of memory reserved
                      by the query service for use with Kubernetes resource scheduling.
                      More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    type: string
                    x-kubernetes-int-or-string: true
                  searchServiceMemoryQuota:
                    anyOf:
                    - type: integer
                    - type: string
                    default: 256Mi
                    description: 'SearchServiceMemQuota is the amount of memory that
                      should be allocated to the search service. This value is per-pod,
                      and only applicable to pods belonging to server classes running
                      the search service.  This field must be a quantity greater than
                      or equal to 256Mi.  This field defaults to 256Mi.  More info:
                      https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                    type: string
                    x-kubernetes-int-or-string: true
                type: object
              enableOnlineVolumeExpansion:
                description: "EnableOnlineVolumeExpansion enables online expansion
                  of Persistent Volumes. You can only expand a PVC if its storage
                  class's \"allowVolumeExpansion\" field is set to true. Additionally,
                  Kubernetes feature \"ExpandInUsePersistentVolumes\" must be enabled
                  in order to expand the volumes which are actively bound to Pods.
                  Volumes can only be expanded and not reduced to a smaller size.
                  See: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#resizing-an-in-use-persistentvolumeclaim
                  \n If \"EnableOnlineVolumeExpansion\" is enabled for use within
                  an environment that does not actually support online volume and
                  file system expansion then the cluster will fallback to rolling
                  upgrade procedure to create a new set of Pods for use with resized
                  Volumes. More info:  https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims"
                type: boolean
              enablePreviewScaling:
                description: DEPRECATED - This option only exists for backwards compatibility
                  and no longer restricts autoscaling to ephemeral services. EnablePreviewScaling
                  enables autoscaling for stateful services and buckets.
                type: boolean
              hibernate:
                description: Hibernate is whether to hibernate the cluster.
                type: boolean
              hibernationStrategy:
                description: HibernationStrategy defines how to hibernate the cluster.  When
                  Immediate the Operator will immediately delete all pods and take
                  no further action until the hibernate field is set to false.
                enum:
                - Immediate
                type: string
              image:
                description: Image is the container image name that will be used to
                  launch Couchbase server instances.  Updating this field will cause
                  an automatic upgrade of the cluster.
                pattern: ^(.*?(:\d+)?/)?.*?/.*?(:.*?\d+\.\d+\.\d+.*|@sha256:[0-9a-f]{64})$
                type: string
              logging:
                description: Logging defines Operator logging options.
                properties:
                  audit:
                    description: Used to manage the audit configuration directly
                    properties:
                      disabledEvents:
                        description: 'The list of event ids to disable for auditing
                          purposes. This is passed to the REST API with no verification
                          by the operator. Refer to the documentation for details:
                          https://docs.couchbase.com/server/current/audit-event-reference/audit-event-reference.html'
                        items:
                          type: integer
                        type: array
                      disabledUsers:
                        description: 'The list of users to ignore for auditing purposes.
                          This is passed to the REST API with minimal validation it
                          meets an acceptable regex pattern. Refer to the documentation
                          for full details on how to configure this: https://docs.couchbase.com/server/current/manage/manage-security/manage-auditing.html#ignoring-events-by-user'
                        items:
                          description: 'The AuditDisabledUser is actually a compound
                            string intended to feed a two-element struct. Its value
                            may be: 1. A local user, specified in the form localusername/local.
                            2. An external user, specified in the form externalusername/external.
                            3. An internal user, specified in the form @internalusername/local.
                            We add a quick validation check to make sure these match
                            and prevent being rejected by the API later. This is just
                            a sanity check, the REST API may still reject the user
                            for other reasons.'
                          pattern: ^.+/(local|external)$
                          type: string
                        type: array
                      enabled:
                        description: Enabled is a boolean that enables the audit capabilities.
                        type: boolean
                      garbageCollection:
                        description: 'Handle all optional garbage collection (GC)
                          configuration for the audit functionality. This is not part
                          of the audit REST API, it is intended to handle GC automatically
                          for the audit logs. By default the Couchbase Server rotates
                          the audit logs but does not clean up the rotated logs. This
                          is left as an operation for the cluster administrator to
                          manage, the operator allows for us to automate this: https://docs.couchbase.com/server/current/manage/manage-security/manage-auditing.html'
                        properties:
                          sidecar:
                            description: Provide the sidecar configuration required
                              (if so desired) to automatically clean up audit logs.
                            properties:
                              age:
                                default: 1h
                                description: The minimum age of rotated log files
                                  to remove, defaults to one hour.
                                type: string
                              enabled:
                                description: Enable this sidecar by setting to true,
                                  defaults to being disabled.
                                type: boolean
                              image:
                                default: busybox:1.33.1
                                description: Image is the image to be used to run
                                  the audit sidecar helper. No validation is carried
                                  out as this can be any arbitrary repo and tag.
                                type: string
                              interval:
                                default: 20m
                                description: The interval at which to check for rotated
                                  log files to remove, defaults to 20 minutes.
                                type: string
                              resources:
                                description: Resources is the resource requirements
                                  for the cleanup container. Will be populated by
                                  Kubernetes defaults if not specified.
                                properties:
                                  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. More info:
                                      https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                    type: object
                                type: object
                            type: object
                        type: object
                      rotation:
                        description: 'The interval to optionally rotate the audit
                          log. This is passed to the REST API, see here for details:
                          https://docs.couchbase.com/server/current/manage/manage-security/manage-auditing.html'
                        properties:
                          interval:
                            default: 15m
                            description: The interval at which to rotate log files,
                              defaults to 15 minutes.
                            type: string
                          size:
                            anyOf:
                            - type: integer
                            - type: string
                            default: 20Mi
                            description: 'Size allows the specification of a rotation
                              size for the log, defaults to 20Mi. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                            type: string
                            x-kubernetes-int-or-string: true
                        type: object
                    type: object
                  logRetentionCount:
                    description: LogRetentionCount gives the number of persistent
                      log PVCs to keep.
                    minimum: 0
                    type: integer
                  logRetentionTime:
                    description: LogRetentionTime gives the time to keep persistent
                      log PVCs alive for.
                    pattern: ^\d+(ns|us|ms|s|m|h)$
                    type: string
                  server:
                    description: Specification of all logging configuration required
                      to manage the sidecar containers in each pod.
                    properties:
                      configurationName:
                        default: fluent-bit-config
                        description: ConfigurationName is the name of the Secret to
                          use holding the logging configuration in the namespace.
                          A Secret is used to ensure we can safely store credentials
                          but this can be populated from plaintext if acceptable too.
                          If it does not exist then one will be created with defaults
                          in the namespace so it can be easily updated whilst running.
                          Note that if running multiple clusters in the same kubernetes
                          namespace then you should use a separate Secret for each,
                          otherwise the first cluster will take ownership (if created)
                          and the Secret will be cleaned up when that cluster is removed.
                          If running clusters in separate namespaces then they will
                          be separate Secrets anyway.
                        type: string
                      enabled:
                        description: Enabled is a boolean that enables the logging
                          sidecar container.
                        type: boolean
                      manageConfiguration:
                        default: true
                        description: A boolean which indicates whether the operator
                          should manage the configuration or not. If omitted then
                          this defaults to true which means the operator will attempt
                          to reconcile it to default values. To use a custom configuration
                          make sure to set this to false. Note that the ownership
                          of any Secret is not changed so if a Secret is created externally
                          it can be updated by the operator but it's ownership stays
                          the same so it will be cleaned up when it's owner is.
                        type: boolean
                      sidecar:
                        default: {}
                        description: Any specific logging sidecar container configuration.
                        properties:
                          configurationMountPath:
                            default: /fluent-bit/config/
                            description: ConfigurationMountPath is the location to
                              mount the ConfigurationName Secret into the image. If
                              another log shipping image is used that needs a different
                              mount then modify this. Note that the configuration
                              file must be called 'fluent-bit.conf' at the root of
                              this path, there is no provision for overriding the
                              name of the config file passed as the COUCHBASE_LOGS_CONFIG_FILE
                              environment variable.
                            type: string
                          image:
                            default: couchbase/fluent-bit:1.1.1
                            description: Image is the image to be used to deal with
                              logging as a sidecar. No validation is carried out as
                              this can be any arbitrary repo and tag. It will default
                              to the latest supported version of Fluent Bit.
                            type: string
                          resources:
                            description: Resources is the resource requirements for
                              the sidecar container. Will be populated by Kubernetes
                              defaults if not specified.
                            properties:
                              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. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                                type: object
                            type: object
                        type: object
                    type: object
                type: object
              monitoring:
                description: Monitoring defines any Operator managed integration into
                  3rd party monitoring infrastructure.
                properties:
                  prometheus:
                    description: Prometheus provides integration with Prometheus monitoring.
                    properties:
                      authorizationSecret:
                        description: AuthorizationSecret is the name of a Kubernetes
                          secret that contains a bearer token to authorize GET requests
                          to the metrics endpoint
                        type: string
                      enabled:
                        description: Enabled is a boolean that enables/disables the
                          metrics sidecar container.
                        type: boolean
                      image:
                        description: Image is the metrics image to be used to collect
                          metrics. No validation is carried out as this can be any
                          arbitrary repo and tag.
                        type: string
                      resources:
                        description: Resources is the resource requirements for the
                          metrics container. Will be populated by Kubernetes defaults
                          if not specified.
                        properties:
                          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.
                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                            type: object
                        type: object
                    required:
                    - image
                    type: object
                type: object
              networking:
                description: Networking defines Couchbase cluster networking options
                  such as network topology, TLS and DDNS settings.
                properties:
                  addressFamily:
                    description: AddressFamily allows the manual selection of the
                      address family to use. When this field is not set, Couchbase
                      server will default to using IPv4 for internal communication
                      and also support IPv6 on dual stack systems. Setting this field
                      to either IPv4 or IPv6 will force Couchbase to use the selected
                      protocol for internal communication, and also disable all other
                      protocols to provide added security and simplicty when defining
                      firewall rules.  Disabling of address families is only supported
                      in Couchbase Server 7.0.2+.
                    enum:
                    - IPv4
                    - IPv6
                    type: string
                  adminConsoleServiceTemplate:
                    description: 'AdminConsoleServiceTemplate provides a template
                      used by the Operator to create and manage the admin console
                      service.  This allows services to be annotated, the service
                      type defined and any other options that Kubernetes provides.  When
                      using a LoadBalancer service type, TLS and dynamic DNS must
                      also be enabled. The Operator reserves the right to modify or
                      replace any field.  More info: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.21/#service-v1-core'
                    properties:
                      metadata:
                        description: Standard objects metadata.  This is a curated
                          version for use with Couchbase resource templates.
                        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: ServiceSpec describes the attributes that a user
                          creates on a service.
                        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. This field is beta-level and is only honored by
                              servers that enable the ServiceLBNodePortControl feature.
                            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.
                              \n 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
                          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 denotes if this Service
                              desires to route external traffic to node-local or cluster-wide
                              endpoints. "Local" preserves the client source IP and
                              avoids a second hop for LoadBalancer and Nodeport type
                              services, but risks potentially imbalanced traffic spreading.
                              "Cluster" obscures the client source IP and may cause
                              a second hop to another node, but should have good overall
                              load-spreading.
                            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).
                            format: int32
                            type: integer
                          internalTrafficPolicy:
                            description: InternalTrafficPolicy specifies if the cluster
                              internal traffic should be routed to all endpoints or
                              node-local endpoints only. "Cluster" routes internal
                              traffic to a Service to all endpoints. "Local" routes
                              traffic to node-local endpoints only, traffic is dropped
                              if no node-local endpoints are ready. The default value
                              is "Cluster".
                            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. \n 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
                              LoadBalancer will get created with the IP specified
                              in this field. 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.'
                            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
                          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
                  adminConsoleServiceType:
                    default: NodePort
                    description: DEPRECATED - by adminConsoleServiceTemplate. AdminConsoleServiceType
                      defines whether to create a node port or load balancer service.
                      When using a LoadBalancer service type, TLS and dynamic DNS
                      must also be enabled. This field must be one of "NodePort" or
                      "LoadBalancer", defaulting to "NodePort".
                    enum:
                    - NodePort
                    - LoadBalancer
                    type: string
                  adminConsoleServices:
                    description: DEPRECATED - not required by Couchbase Server 6.5.0
                      onward. AdminConsoleServices is a selector to choose specific
                      services to expose via the admin console. This field may contain
                      any of "data", "index", "query", "search", "eventing" and "analytics".  Each
                      service may only be included once.
                    items:
                      description: Supported services
                      enum:
                      - admin
                      - data
                      - index
                      - query
                      - search
                      - eventing
                      - analytics
                      type: string
                    type: array
                    x-kubernetes-list-type: set
                  disableUIOverHTTP:
                    description: DisableUIOverHTTP is used to explicitly enable and
                      disable UI access over the HTTP protocol.  If not specified,
                      this field defaults to false.
                    type: boolean
                  disableUIOverHTTPS:
                    description: DisableUIOverHTTPS is used to explicitly enable and
                      disable UI access over the HTTPS protocol.  If not specified,
                      this field defaults to false.
                    type: boolean
                  dns:
                    description: DNS defines information required for Dynamic DNS
                      support.
                    properties:
                      domain:
                        description: Domain is the domain to create pods in.  When
                          populated the Operator will annotate the admin console and
                          per-pod services with the key "external-dns.alpha.kubernetes.io/hostname".  These
                          annotations can be used directly by a Kubernetes External-DNS
                          controller to replicate load balancer service IP addresses
                          into a public DNS server.
                        type: string
                    type: object
                  exposeAdminConsole:
                    description: ExposeAdminConsole creates a service referencing
                      the admin console. The service is configured by the adminConsoleServiceTemplate
                      field.
                    type: boolean
                  exposedFeatureServiceTemplate:
                    description: 'ExposedFeatureServiceTemplate provides a template
                      used by the Operator to create and manage per-pod services.  This
                      allows services to be annotated, the service type defined and
                      any other options that Kubernetes provides.  When using a LoadBalancer
                      service type, TLS and dynamic DNS must also be enabled. The
                      Operator reserves the right to modify or replace any field.  More
                      info: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.21/#service-v1-core'
                    properties:
                      metadata:
                        description: Standard objects metadata.  This is a curated
                          version for use with Couchbase resource templates.
                        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: ServiceSpec describes the attributes that a user
                          creates on a service.
                        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. This field is beta-level and is only honored by
                              servers that enable the ServiceLBNodePortControl feature.
                            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.
                              \n 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
                          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 denotes if this Service
                              desires to route external traffic to node-local or cluster-wide
                              endpoints. "Local" preserves the client source IP and
                              avoids a second hop for LoadBalancer and Nodeport type
                              services, but risks potentially imbalanced traffic spreading.
                              "Cluster" obscures the client source IP and may cause
                              a second hop to another node, but should have good overall
                              load-spreading.
                            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).
                            format: int32
                            type: integer
                          internalTrafficPolicy:
                            description: InternalTrafficPolicy specifies if the cluster
                              internal traffic should be routed to all endpoints or
                              node-local endpoints only. "Cluster" routes internal
                              traffic to a Service to all endpoints. "Local" routes
                              traffic to node-local endpoints only, traffic is dropped
                              if no node-local endpoints are ready. The default value
                              is "Cluster".
                            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. \n 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
                              LoadBalancer will get created with the IP specified
                              in this field. 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.'
                            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
                          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
                  exposedFeatureServiceType:
                    default: NodePort
                    description: DEPRECATED - by exposedFeatureServiceTemplate. ExposedFeatureServiceType
                      defines whether to create a node port or load balancer service.
                      When using a LoadBalancer service type, TLS and dynamic DNS
                      must also be enabled. This field must be one of "NodePort" or
                      "LoadBalancer", defaulting to "NodePort".
                    enum:
                    - NodePort
                    - LoadBalancer
                    type: string
                  exposedFeatureTrafficPolicy:
                    description: DEPRECATED  - by exposedFeatureServiceTemplate. ExposedFeatureTrafficPolicy
                      defines how packets should be routed from a load balancer service
                      to a Couchbase pod.  When local, traffic is routed directly
                      to the pod.  When cluster, traffic is routed to any node, then
                      forwarded on.  While cluster routing may be slower, there are
                      some situations where it is required for connectivity.  This
                      field must be either "Cluster" or "Local", defaulting to "Local",
                    enum:
                    - Cluster
                    - Local
                    type: string
                  exposedFeatures:
                    description: ExposedFeatures is a list of Couchbase features to
                      expose when using a networking model that exposes the Couchbase
                      cluster externally to Kubernetes.  This field also triggers
                      the creation of per-pod services used by clients to connect
                      to the Couchbase cluster.  When admin, only the administrator
                      port is exposed, allowing remote administration.  When xdcr,
                      only the services required for remote replication are exposed.
                      The xdcr feature is only required when the cluster is the destination
                      of an XDCR replication.  When client, all services are exposed
                      as required for client SDK operation. This field may contain
                      any of "admin", "xdcr" and "client".  Each feature may only
                      be included once.
                    items:
                      enum:
                      - admin
                      - xdcr
                      - client
                      type: string
                    type: array
                    x-kubernetes-list-type: set
                  loadBalancerSourceRanges:
                    description: DEPRECATED - by adminConsoleServiceTemplate and exposedFeatureServiceTemplate.
                      LoadBalancerSourceRanges applies only when an exposed service
                      is of type LoadBalancer and limits the source IP ranges that
                      are allowed to use the service.  Items must use IPv4 class-less
                      interdomain routing (CIDR) notation e.g. 10.0.0.0/16.
                    items:
                      pattern: ^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/\d{1,2}$
                      type: string
                    type: array
                  networkPlatform:
                    description: NetworkPlatform is used to enable support for various
                      networking technologies.  This field must be one of "Istio".
                    enum:
                    - Istio
                    type: string
                  serviceAnnotations:
                    additionalProperties:
                      type: string
                    description: DEPRECATED - by adminConsoleServiceTemplate and exposedFeatureServiceTemplate.
                      ServiceAnnotations allows services to be annotated with custom
                      labels. Operator annotations are merged on top of these so have
                      precedence as they are required for correct operation.
                    type: object
                  tls:
                    description: TLS defines the TLS configuration for the cluster
                      including server and client certificate configuration, and TLS
                      security policies.
                    properties:
                      cipherSuites:
                        description: CipherSuites specifies a list of cipher suites
                          for Couchbase server to select from when negotiating TLS
                          handshakes with a client.  Suites are not validated by the
                          Operator.  Run "openssl ciphers -v" in a Couchbase server
                          pod to interrogate supported values.
                        items:
                          type: string
                        type: array
                        x-kubernetes-list-type: set
                      clientCertificatePaths:
                        description: ClientCertificatePaths defines where to look
                          in client certificates in order to extract the user name.
                        items:
                          description: ClientCertificatePath defines how to extract
                            a username from a client ceritficate.
                          properties:
                            delimiter:
                              description: Delimiter if specified allows a suffix
                                to be stripped from the username, once extracted from
                                the certificate path.
                              type: string
                            path:
                              description: Path defines where in the X.509 specification
                                to extract the username from. This field must be either
                                "subject.cn", "san.uri", "san.dnsname" or  "san.email".
                              pattern: ^subject\.cn|san\.uri|san\.dnsname|san\.email$
                              type: string
                            prefix:
                              description: Prefix allows a prefix to be stripped from
                                the username, once extracted from the certificate
                                path.
                              type: string
                          required:
                          - path
                          type: object
                        type: array
                      clientCertificatePolicy:
                        description: ClientCertificatePolicy defines the client authentication
                          policy to use. If set, the Operator expects TLS configuration
                          to contain a valid certificate/key pair for the Administrator
                          account.
                        enum:
                        - enable
                        - mandatory
                        type: string
                      nodeToNodeEncryption:
                        description: NodeToNodeEncryption specifies whether to encrypt
                          data between Couchbase nodes within the same cluster.  This
                          may come at the expense of performance.  When control plane
                          only encryption is used, only cluster management traffic
                          is encrypted between nodes.  When all, all traffic is encrypted,
                          including database documents. When strict mode is used,
                          it is the same as all, but also disables all plaintext ports.  Strict
                          mode is only available on Couchbase Server versions 7.1
                          and greater. Node to node encryption can only be used when
                          TLS certificates are managed by the Operator.  This field
                          must be either "ControlPlaneOnly", "All", or "Strict".
                        enum:
                        - ControlPlaneOnly
                        - All
                        - Strict
                        type: string
                      rootCAs:
                        description: RootCAs defines a set of secrets that reside
                          in this namespace that contain additional CA certificates
                          that should be installed in Couchbase.  The CA certificates
                          that are defined here are in addition to those defined for
                          the cluster, optionally by couchbaseclusters.spec.networking.tls.secretSource,
                          and thus should not be duplicated.  Secrets referred to
                          must be of well-know type "kubernetes.io/tls" and must contain
                          the CA certificate under the key "tls.crt". Multiple root
                          CA certificates are only supported on Couchbase Server 7.1
                          and greater, and not with legacy couchbaseclusters.spec.networking.tls.static
                          configuration.
                        items:
                          type: string
                        type: array
                      secretSource:
                        description: SecretSource enables the user to specify a secret
                          conforming to the Kubernetes TLS secret specification that
                          is used for the Couchbase server certificate, and optionally
                          the Operator's client certificate, providing cert-manager
                          compatibility without having to specify a separate root
                          CA.  A server CA certificate must be supplied by one of
                          the provided methods. Certificates referred to must be of
                          well-known type "kubernetes.io/tls".
                        properties:
                          clientSecretName:
                            description: ClientSecretName specifies the secret name,
                              in the same namespace as the cluster, the contains client
                              TLS data.  The secret is expected to contain "tls.crt"
                              and "tls.key" as per the Kubernetes.io/tls secret type.
                            type: string
                          serverSecretName:
                            description: ServerSecretName specifies the secret name,
                              in the same namespace as the cluster, that contains
                              server TLS data.  The secret is expected to contain
                              "tls.crt" and "tls.key" as per the kubernetes.io/tls
                              secret type.  It may also contain "ca.crt".
                            type: string
                        required:
                        - serverSecretName
                        type: object
                      static:
                        description: DEPRECATED - by couchbaseclusters.spec.networking.tls.secretSource.
                          Static enables user to generate static x509 certificates
                          and keys, put them into Kubernetes secrets, and specify
                          them here.  Static secrets are Couchbase specific, and follow
                          no well-known standards.
                        properties:
                          operatorSecret:
                            description: OperatorSecret is a secret name containing
                              TLS certs used by operator to talk securely to this
                              cluster.  The secret must contain a CA certificate (data
                              key ca.crt).  If client authentication is enabled, then
                              the secret must also contain a client certificate chain
                              (data key "couchbase-operator.crt") and private key
                              (data key "couchbase-operator.key").
                            type: string
                          serverSecret:
                            description: ServerSecret is a secret name containing
                              TLS certs used by each Couchbase member pod for the
                              communication between Couchbase server and its clients.  The
                              secret must contain a certificate chain (data key "couchbase-operator.crt")
                              and a private key (data key "couchbase-operator.key").  The
                              private key must be in the PKCS#1 RSA format.  The certificate
                              chain must have a required set of X.509v3 subject alternative
                              names for all cluster addressing modes.  See the Operator
                              TLS documentation for more information.
                            type: string
                        type: object
                      tlsMinimumVersion:
                        default: TLS1.2
                        description: TLSMinimumVersion specifies the minimum TLS version
                          the Couchbase server can negotiate with a client.  Must
                          be one of TLS1.0, TLS1.1 TLS1.2 or TLS1.3, defaulting to
                          TLS1.2.  TLS1.3 is only valid for Couchbase Server 7.1.0
                          onward.
                        enum:
                        - TLS1.0
                        - TLS1.1
                        - TLS1.2
                        - TLS1.3
                        type: string
                    type: object
                  waitForAddressReachable:
                    default: 10m
                    description: WaitForAddressReachable is used to set the timeout
                      between when polling of external addresses is started, and when
                      it is deemed a failure.  Polling of DNS name availability inherently
                      dangerous due to negative caching, so prefer the use of an initial
                      `waitForAddressReachableDelay` to allow propagation.
                    type: string
                  waitForAddressReachableDelay:
                    default: 2m
                    description: WaitForAddressReachableDelay is used to defer operator
                      checks that ensure external addresses are reachable before new
                      nodes are balanced in to the cluster.  This prevents negative
                      DNS caching while waiting for external-DDNS controllers to propagate
                      addresses.
                    type: string
                type: object
              paused:
                description: Paused is to pause the control of the operator for the
                  Couchbase cluster. This does not pause the cluster itself, instead
                  stopping the operator from taking any action.
                type: boolean
              platform:
                description: Platform gives a hint as to what platform we are running
                  on and how to configure services.  This field must be one of "aws",
                  "gke" or "azure".
                enum:
                - aws
                - gce
                - azure
                type: string
              recoveryPolicy:
                description: RecoveryPolicy controls how aggressive the Operator is
                  when recovering cluster topology.  When PrioritizeDataIntegrity,
                  the Operator will delegate failover exclusively to Couchbase server,
                  relying on it to only allow recovery when safe to do so.  When PrioritizeUptime,
                  the Operator will wait for a period after the expected auto-failover
                  of the cluster, before forcefully failing-over the pods. This may
                  cause data loss, and is only expected to be used on clusters with
                  ephemeral data, where the loss of the pod means that the data is
                  known to be unrecoverable. This field must be either "PrioritizeDataIntegrity"
                  or "PrioritizeUptime", defaulting to "PrioritizeDataIntegrity".
                enum:
                - PrioritizeDataIntegrity
                - PrioritizeUptime
                type: string
              rollingUpgrade:
                description: When `spec.upgradeStrategy` is set to `RollingUpgrade`
                  it will, by default, upgrade one pod at a time.  If this field is
                  specified then that number can be increased.
                properties:
                  maxUpgradable:
                    description: MaxUpgradable allows the number of pods affected
                      by an upgrade at any one time to be increased.  By default a
                      rolling upgrade will upgrade one pod at a time.  This field
                      allows that limit to be removed. This field must be greater
                      than zero. The smallest of `maxUpgradable` and `maxUpgradablePercent`
                      takes precedence if both are defined.
                    minimum: 1
                    type: integer
                  maxUpgradablePercent:
                    description: MaxUpgradablePercent allows the number of pods affected
                      by an upgrade at any one time to be increased.  By default a
                      rolling upgrade will upgrade one pod at a time.  This field
                      allows that limit to be removed. This field must be an integer
                      percentage, e.g. "10%", in the range 1% to 100%. Percentages
                      are relative to the total cluster size, and rounded down to
                      the nearest whole number, with a minimum of 1.  For example,
                      a 10 pod cluster, and 25% allowed to upgrade, would yield 2.5
                      pods per iteration, rounded down to 2. The smallest of `maxUpgradable`
                      and `maxUpgradablePercent` takes precedence if both are defined.
                    pattern: ^(100|[1-9][0-9]|[1-9])%$
                    type: string
                type: object
              security:
                description: Security defines Couchbase cluster security options such
                  as the administrator account username and password, and user RBAC
                  settings.
                properties:
                  adminSecret:
                    description: AdminSecret is the name of a Kubernetes secret to
                      use for administrator authentication. The admin secret must
                      contain the keys "username" and "password".  The password data
                      must be at least 6 characters in length, and not contain the
                      any of the characters `()<>,;:\"/[]?={}`.
                    type: string
                  ldap:
                    description: LDAP Settings
                    properties:
                      authenticationEnabled:
                        default: true
                        description: Enables using LDAP to authenticate users.
                        type: boolean
                      authorizationEnabled:
                        description: Enables use of LDAP groups for authorization.
                        type: boolean
                      bindDN:
                        description: 'DN to use for searching users and groups synchronization.
                          More info: https://docs.couchbase.com/server/current/manage/manage-security/configure-ldap.html'
                        type: string
                      bindSecret:
                        description: BindSecret is the name of a Kubernetes secret
                          to use containing password for LDAP user binding
                        type: string
                      cacert:
                        description: CA Certificate in PEM format to be used in LDAP
                          server certificate validation
                        type: string
                      cacheValueLifetime:
                        default: 30000
                        description: 'Lifetime of values in cache in milliseconds.
                          Default 300000 ms.  More info: https://docs.couchbase.com/server/current/manage/manage-security/configure-ldap.html'
                        format: int64
                        type: integer
                      encryption:
                        description: Encryption method to communicate with LDAP servers.
                          Can be StartTLSExtension, TLS, or false.
                        enum:
                        - None
                        - StartTLSExtension
                        - TLS
                        type: string
                      groupsQuery:
                        description: 'LDAP query, to get the users'' groups by username
                          in RFC4516 format.  More info: https://docs.couchbase.com/server/current/manage/manage-security/configure-ldap.html'
                        type: string
                      hosts:
                        description: List of LDAP hosts.
                        items:
                          type: string
                        minItems: 1
                        type: array
                      nestedGroupsEnabled:
                        description: 'If enabled Couchbase server will try to recursively
                          search for groups for every discovered ldap group. groups_query
                          will be user for the search. More info: https://docs.couchbase.com/server/current/manage/manage-security/configure-ldap.html'
                        type: boolean
                      nestedGroupsMaxDepth:
                        default: 10
                        description: 'Maximum number of recursive groups requests
                          the server is allowed to perform. Requires NestedGroupsEnabled.  Values
                          between 1 and 100: the default is 10. More info: https://docs.couchbase.com/server/current/manage/manage-security/configure-ldap.html'
                        format: int64
                        maximum: 100
                        minimum: 1
                        type: integer
                      port:
                        default: 389
                        description: LDAP port. This is typically 389 for LDAP, and
                          636 for LDAPS.
                        type: integer
                      serverCertValidation:
                        description: Whether server certificate validation be enabled
                        type: boolean
                      tlsSecret:
                        description: TLSSecret is the name of a Kubernetes secret
                          to use for LDAP ca cert.
                        type: string
                      userDNMapping:
                        description: 'User to distinguished name (DN) mapping. If
                          none is specified, the username is used as the user’s distinguished
                          name.  More info: https://docs.couchbase.com/server/current/manage/manage-security/configure-ldap.html'
                        properties:
                          query:
                            description: Query is the LDAP query to run to map from
                              Couchbase user to LDAP distinguished name.
                            type: string
                          template:
                            description: This field specifies list of templates to
                              use for providing username to DN mapping. The template
                              may contain a placeholder specified as `%u` to represent
                              the Couchbase user who is attempting to gain access.
                            type: string
                        type: object
                    required:
                    - bindSecret
                    - hosts
                    - port
                    type: object
                  rbac:
                    description: Couchbase RBAC Users
                    properties:
                      managed:
                        description: Managed defines whether RBAC is managed by us
                          or the clients.
                        type: boolean
                      selector:
                        description: Selector is a label selector used to list RBAC
                          resources in the namespace that are managed by the Operator.
                        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
                              required:
                              - key
                              - operator
                              type: object
                            type: array
                          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
                    type: object
                required:
                - adminSecret
                type: object
              securityContext:
                description: 'SecurityContext allows the configuration of the security
                  context for all Couchbase server pods.  When using persistent volumes
                  you may need to set the fsGroup field in order to write to the volume.  For
                  non-root clusters you must also set runAsUser to 1000, corresponding
                  to the Couchbase user in official container images.  More info:
                  https://kubernetes.io/docs/tasks/configure-pod-container/security-context/'
                properties:
                  fsGroup:
                    description: "A special supplemental group that applies to all
                      containers in a pod. Some volume types allow the Kubelet to
                      change the ownership of that volume to be owned by the pod:
                      \n 1. The owning GID will be the FSGroup 2. The setgid bit is
                      set (new files created in the volume will be owned by FSGroup)
                      3. The permission bits are OR'd with rw-rw---- \n If unset,
                      the Kubelet will not modify the ownership and permissions of
                      any volume. Note that this field cannot be set when spec.os.name
                      is windows."
                    format: int64
                    type: integer
                  fsGroupChangePolicy:
                    description: 'fsGroupChangePolicy defines behavior of changing
                      ownership and permission of the volume before being exposed
                      inside Pod. This field will only apply to volume types which
                      support fsGroup based ownership(and permissions). It will have
                      no effect on ephemeral volume types such as: secret, configmaps
                      and emptydir. Valid values are "OnRootMismatch" and "Always".
                      If not specified, "Always" is used. Note that this field cannot
                      be set when spec.os.name is windows.'
                    type: string
                  runAsGroup:
                    description: The GID to run the entrypoint of the container process.
                      Uses runtime default if unset. May also be set in SecurityContext.  If
                      set in both SecurityContext and PodSecurityContext, the value
                      specified in SecurityContext takes precedence for that container.
                      Note that this field cannot be set when spec.os.name is windows.
                    format: int64
                    type: integer
                  runAsNonRoot:
                    description: Indicates that the container must run as a non-root
                      user. If true, the Kubelet will validate the image at runtime
                      to ensure that it does not run as UID 0 (root) and fail to start
                      the container if it does. If unset or false, no such validation
                      will be performed. May also be set in SecurityContext.  If set
                      in both SecurityContext and PodSecurityContext, the value specified
                      in SecurityContext takes precedence.
                    type: boolean
                  runAsUser:
                    description: The UID to run the entrypoint of the container process.
                      Defaults to user specified in image metadata if unspecified.
                      May also be set in SecurityContext.  If set in both SecurityContext
                      and PodSecurityContext, the value specified in SecurityContext
                      takes precedence for that container. Note that this field cannot
                      be set when spec.os.name is windows.
                    format: int64
                    type: integer
                  seLinuxOptions:
                    description: The SELinux context to be applied to all containers.
                      If unspecified, the container runtime will allocate a random
                      SELinux context for each container.  May also be set in SecurityContext.  If
                      set in both SecurityContext and PodSecurityContext, the value
                      specified in SecurityContext takes precedence for that container.
                      Note that this field cannot be set when spec.os.name is windows.
                    properties:
                      level:
                        description: Level is SELinux level label that applies to
                          the container.
                        type: string
                      role:
                        description: Role is a SELinux role label that applies to
                          the container.
                        type: string
                      type:
                        description: Type is a SELinux type label that applies to
                          the container.
                        type: string
                      user:
                        description: User is a SELinux user label that applies to
                          the container.
                        type: string
                    type: object
                  seccompProfile:
                    description: The seccomp options to use by the containers in this
                      pod. Note that this field cannot be set when spec.os.name is
                      windows.
                    properties:
                      localhostProfile:
                        description: localhostProfile indicates a profile defined
                          in a file on the node should be used. The profile must be
                          preconfigured on the node to work. Must be a descending
                          path, relative to the kubelet's configured seccomp profile
                          location. Must only be set if type is "Localhost".
                        type: string
                      type:
                        description: "type indicates which kind of seccomp profile
                          will be applied. Valid options are: \n Localhost - a profile
                          defined in a file on the node should be used. RuntimeDefault
                          - the container runtime default profile should be used.
                          Unconfined - no profile should be applied."
                        type: string
                    required:
                    - type
                    type: object
                  supplementalGroups:
                    description: A list of groups applied to the first process run
                      in each container, in addition to the container's primary GID.  If
                      unspecified, no groups will be added to any container. Note
                      that this field cannot be set when spec.os.name is windows.
                    items:
                      format: int64
                      type: integer
                    type: array
                  sysctls:
                    description: Sysctls hold a list of namespaced sysctls used for
                      the pod. Pods with unsupported sysctls (by the container runtime)
                      might fail to launch. Note that this field cannot be set when
                      spec.os.name is windows.
                    items:
                      description: Sysctl defines a kernel parameter to be set
                      properties:
                        name:
                          description: Name of a property to set
                          type: string
                        value:
                          description: Value of a property to set
                          type: string
                      required:
                      - name
                      - value
                      type: object
                    type: array
                  windowsOptions:
                    description: The Windows specific settings applied to all containers.
                      If unspecified, the options within a container's SecurityContext
                      will be used. If set in both SecurityContext and PodSecurityContext,
                      the value specified in SecurityContext takes precedence. Note
                      that this field cannot be set when spec.os.name is linux.
                    properties:
                      gmsaCredentialSpec:
                        description: GMSACredentialSpec is where the GMSA admission
                          webhook (https://github.com/kubernetes-sigs/windows-gmsa)
                          inlines the contents of the GMSA credential spec named by
                          the GMSACredentialSpecName field.
                        type: string
                      gmsaCredentialSpecName:
                        description: GMSACredentialSpecName is the name of the GMSA
                          credential spec to use.
                        type: string
                      hostProcess:
                        description: HostProcess determines if a container should
                          be run as a 'Host Process' container. This field is alpha-level
                          and will only be honored by components that enable the WindowsHostProcessContainers
                          feature flag. Setting this field without the feature flag
                          will result in errors when validating the Pod. All of a
                          Pod's containers must have the same effective HostProcess
                          value (it is not allowed to have a mix of HostProcess containers
                          and non-HostProcess containers).  In addition, if HostProcess
                          is true then HostNetwork must also be set to true.
                        type: boolean
                      runAsUserName:
                        description: The UserName in Windows to run the entrypoint
                          of the container process. Defaults to the user specified
                          in image metadata if unspecified. May also be set in PodSecurityContext.
                          If set in both SecurityContext and PodSecurityContext, the
                          value specified in SecurityContext takes precedence.
                        type: string
                    type: object
                type: object
              serverGroups:
                description: ServerGroups define the set of availability zones you
                  want to distribute pods over, and construct Couchbase server groups
                  for.  By default, most cloud providers will label nodes with the
                  key "topology.kubernetes.io/zone", the values associated with that
                  key are used here to provide explicit scheduling by the Operator.  You
                  may manually label nodes using the "topology.kubernetes.io/zone"
                  key, to provide failure-domain aware scheduling when none is provided
                  for you.  Global server groups are applied to all server classes,
                  and may be overridden on a per-server class basis to give more control
                  over scheduling and server groups.
                items:
                  type: string
                type: array
                x-kubernetes-list-type: set
              servers:
                description: Servers defines server classes for the Operator to provision
                  and manage. A server class defines what services are running and
                  how many members make up that class.  Specifying multiple server
                  classes allows the Operator to provision clusters with Multi-Dimensional
                  Scaling (MDS).  At least one server class must be defined, and at
                  least one server class must be running the data service.
                items:
                  properties:
                    autoscaleEnabled:
                      description: AutoscaledEnabled defines whether the autoscaling
                        feature is enabled for this class. When true, the Operator
                        will create a CouchbaseAutoscaler resource for this server
                        class.  The CouchbaseAutoscaler implements the Kubernetes
                        scale API and can be controlled by the Kubernetes horizontal
                        pod autoscaler (HPA).
                      type: boolean
                    env:
                      description: Env allows the setting of environment variables
                        in the Couchbase server container.
                      items:
                        description: EnvVar represents an environment variable present
                          in a Container.
                        properties:
                          name:
                            description: Name of the environment variable. Must be
                              a C_IDENTIFIER.
                            type: string
                          value:
                            description: 'Variable references $(VAR_NAME) are expanded
                              using the previously defined environment variables in
                              the container and any service environment variables.
                              If a variable cannot be resolved, the reference in the
                              input string will be unchanged. Double $$ are reduced
                              to a single $, which allows for escaping the $(VAR_NAME)
                              syntax: i.e. "$$(VAR_NAME)" will produce the string
                              literal "$(VAR_NAME)". Escaped references will never
                              be expanded, regardless of whether the variable exists
                              or not. Defaults to "".'
                            type: string
                          valueFrom:
                            description: Source for the environment variable's value.
                              Cannot be used if value is not empty.
                            properties:
                              configMapKeyRef:
                                description: Selects a key of a ConfigMap.
                                properties:
                                  key:
                                    description: The key to select.
                                    type: string
                                  name:
                                    description: 'Name of the referent. More info:
                                      https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                                      TODO: Add other useful fields. apiVersion, kind,
                                      uid?'
                                    type: string
                                  optional:
                                    description: Specify whether the ConfigMap or
                                      its key must be defined
                                    type: boolean
                                required:
                                - key
                                type: object
                              fieldRef:
                                description: 'Selects a field of the pod: supports
                                  metadata.name, metadata.namespace, `metadata.labels[''<KEY>'']`,
                                  `metadata.annotations[''<KEY>'']`, spec.nodeName,
                                  spec.serviceAccountName, status.hostIP, status.podIP,
                                  status.podIPs.'
                                properties:
                                  apiVersion:
                                    description: Version of the schema the FieldPath
                                      is written in terms of, defaults to "v1".
                                    type: string
                                  fieldPath:
                                    description: Path of the field to select in the
                                      specified API version.
                                    type: string
                                required:
                                - fieldPath
                                type: object
                              resourceFieldRef:
                                description: 'Selects a resource of the container:
                                  only resources limits and requests (limits.cpu,
                                  limits.memory, limits.ephemeral-storage, requests.cpu,
                                  requests.memory and requests.ephemeral-storage)
                                  are currently supported.'
                                properties:
                                  containerName:
                                    description: 'Container name: required for volumes,
                                      optional for env vars'
                                    type: string
                                  divisor:
                                    anyOf:
                                    - type: integer
                                    - type: string
                                    description: Specifies the output format of the
                                      exposed resources, defaults to "1"
                                    pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                    x-kubernetes-int-or-string: true
                                  resource:
                                    description: 'Required: resource to select'
                                    type: string
                                required:
                                - resource
                                type: object
                              secretKeyRef:
                                description: Selects a key of a secret in the pod's
                                  namespace
                                properties:
                                  key:
                                    description: The key of the secret to select from.  Must
                                      be a valid secret key.
                                    type: string
                                  name:
                                    description: 'Name of the referent. More info:
                                      https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                                      TODO: Add other useful fields. apiVersion, kind,
                                      uid?'
                                    type: string
                                  optional:
                                    description: Specify whether the Secret or its
                                      key must be defined
                                    type: boolean
                                required:
                                - key
                                type: object
                            type: object
                        required:
                        - name
                        type: object
                      type: array
                    envFrom:
                      description: EnvFrom allows the setting of environment variables
                        in the Couchbase server container.
                      items:
                        description: EnvFromSource represents the source of a set
                          of ConfigMaps
                        properties:
                          configMapRef:
                            description: The ConfigMap to select from
                            properties:
                              name:
                                description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                                  TODO: Add other useful fields. apiVersion, kind,
                                  uid?'
                                type: string
                              optional:
                                description: Specify whether the ConfigMap must be
                                  defined
                                type: boolean
                            type: object
                          prefix:
                            description: An optional identifier to prepend to each
                              key in the ConfigMap. Must be a C_IDENTIFIER.
                            type: string
                          secretRef:
                            description: The Secret to select from
                            properties:
                              name:
                                description: 'Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                                  TODO: Add other useful fields. apiVersion, kind,
                                  uid?'
                                type: string
                              optional:
                                description: Specify whether the Secret must be defined
                                type: boolean
                            type: object
                        type: object
                      type: array
                    name:
                      description: Name is a textual name for the server configuration
                        and must be unique. The name is used by the operator to uniquely
                        identify a server class, and map pods back to an intended
                        configuration.
                      type: string
                    pod:
                      description: 'Pod defines a template used to create pod for
                        each Couchbase server instance.  Modifying pod metadata such
                        as labels and annotations will update the pod in-place.  Any
                        other modification will result in a cluster upgrade in order
                        to fulfill the request. The Operator reserves the right to
                        modify or replace any field.  More info: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.21/#pod-v1-core'
                      properties:
                        metadata:
                          description: Standard objects metadata.  This is a curated
                            version for use with Couchbase resource templates.
                          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: PodSpec is a description of a pod.
                          properties:
                            activeDeadlineSeconds:
                              description: Optional duration in seconds the pod may
                                be active on the node relative to StartTime before
                                the system will actively try to mark it failed and
                                kill associated containers. Value must be a positive
                                integer.
                              format: int64
                              type: integer
                            automountServiceAccountToken:
                              description: AutomountServiceAccountToken indicates
                                whether a service account token should be automatically
                                mounted.
                              type: boolean
                            dnsConfig:
                              description: Specifies the DNS parameters of a pod.
                                Parameters specified here will be merged to the generated
                                DNS configuration based on DNSPolicy.
                              properties:
                                nameservers:
                                  description: A list of DNS name server IP addresses.
                                    This will be appended to the base nameservers
                                    generated from DNSPolicy. Duplicated nameservers
                                    will be removed.
                                  items:
                                    type: string
                                  type: array
                                options:
                                  description: A list of DNS resolver options. This
                                    will be merged with the base options generated
                                    from DNSPolicy. Duplicated entries will be removed.
                                    Resolution options given in Options will override
                                    those that appear in the base DNSPolicy.
                                  items:
                                    description: PodDNSConfigOption defines DNS resolver
                                      options of a pod.
                                    properties:
                                      name:
                                        description: Required.
                                        type: string
                                      value:
                                        type: string
                                    type: object
                                  type: array
                                searches:
                                  description: A list of DNS search domains for host-name
                                    lookup. This will be appended to the base search
                                    paths generated from DNSPolicy. Duplicated search
                                    paths will be removed.
                                  items:
                                    type: string
                                  type: array
                              type: object
                            dnsPolicy:
                              description: Set DNS policy for the pod. Defaults to
                                "ClusterFirst". Valid values are 'ClusterFirstWithHostNet',
                                'ClusterFirst', 'Default' or 'None'. DNS parameters
                                given in DNSConfig will be merged with the policy
                                selected with DNSPolicy. To have DNS options set along
                                with hostNetwork, you have to specify DNS policy explicitly
                                to 'ClusterFirstWithHostNet'.
                              type: string
                            enableServiceLinks:
                              description: 'EnableServiceLinks indicates whether information
                                about services should be injected into pod''s environment
                                variables, matching the syntax of Docker links. Optional:
                                Defaults to true.'
                              type: boolean
                            hostIPC:
                              description: 'Use the host''s ipc namespace. Optional:
                                Default to false.'
                              type: boolean
                            hostNetwork:
                              description: Host networking requested for this pod.
                                Use the host's network namespace. If this option is
                                set, the ports that will be used must be specified.
                                Default to false.
                              type: boolean
                            hostPID:
                              description: 'Use the host''s pid namespace. Optional:
                                Default to false.'
                              type: boolean
                            imagePullSecrets:
                              description: 'ImagePullSecrets is an optional list of
                                references to secrets in the same namespace to use
                                for pulling any of the images used by this PodSpec.
                                If specified, these secrets will be passed to individual
                                puller implementations for them to use. For example,
                                in the case of docker, only DockerConfig type secrets
                                are honored. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod'
                              items:
                                description: LocalObjectReference contains enough
                                  information to let you locate the referenced object
                                  inside the same namespace.
                                properties:
                                  name:
                                    description: 'Name of the referent. More info:
                                      https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                                      TODO: Add other useful fields. apiVersion, kind,
                                      uid?'
                                    type: string
                                type: object
                              type: array
                            nodeName:
                              description: NodeName is a request to schedule this
                                pod onto a specific node. If it is non-empty, the
                                scheduler simply schedules this pod onto that node,
                                assuming that it fits resource requirements.
                              type: string
                            nodeSelector:
                              additionalProperties:
                                type: string
                              description: 'NodeSelector is a selector which must
                                be true for the pod to fit on a node. Selector which
                                must match a node''s labels for the pod to be scheduled
                                on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/'
                              type: object
                              x-kubernetes-map-type: atomic
                            os:
                              description: "Specifies the OS of the containers in
                                the pod. Some pod and container fields are restricted
                                if this is set. \n If the OS field is set to linux,
                                the following fields must be unset: -securityContext.windowsOptions
                                \n If the OS field is set to windows, following fields
                                must be unset: - spec.hostPID - spec.hostIPC - spec.securityContext.seLinuxOptions
                                - spec.securityContext.seccompProfile - spec.securityContext.fsGroup
                                - spec.securityContext.fsGroupChangePolicy - spec.securityContext.sysctls
                                - spec.shareProcessNamespace - spec.securityContext.runAsUser
                                - spec.securityContext.runAsGroup - spec.securityContext.supplementalGroups
                                - spec.containers[*].securityContext.seLinuxOptions
                                - spec.containers[*].securityContext.seccompProfile
                                - spec.containers[*].securityContext.capabilities
                                - spec.containers[*].securityContext.readOnlyRootFilesystem
                                - spec.containers[*].securityContext.privileged -
                                spec.containers[*].securityContext.allowPrivilegeEscalation
                                - spec.containers[*].securityContext.procMount - spec.containers[*].securityContext.runAsUser
                                - spec.containers[*].securityContext.runAsGroup This
                                is an alpha field and requires the IdentifyPodOS feature"
                              properties:
                                name:
                                  description: 'Name is the name of the operating
                                    system. The currently supported values are linux
                                    and windows. Additional value may be defined in
                                    future and can be one of: https://github.com/opencontainers/runtime-spec/blob/master/config.md#platform-specific-configuration
                                    Clients should expect to handle additional values
                                    and treat unrecognized values in this field as
                                    os: null'
                                  type: string
                              required:
                              - name
                              type: object
                            overhead:
                              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: 'Overhead represents the resource overhead
                                associated with running a pod for a given RuntimeClass.
                                This field will be autopopulated at admission time
                                by the RuntimeClass admission controller. If the RuntimeClass
                                admission controller is enabled, overhead must not
                                be set in Pod create requests. The RuntimeClass admission
                                controller will reject Pod create requests which have
                                the overhead already set. If RuntimeClass is configured
                                and selected in the PodSpec, Overhead will be set
                                to the value defined in the corresponding RuntimeClass,
                                otherwise it will remain unset and treated as zero.
                                More info: https://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md
                                This field is beta-level as of Kubernetes v1.18, and
                                is only honored by servers that enable the PodOverhead
                                feature.'
                              type: object
                            preemptionPolicy:
                              description: PreemptionPolicy is the Policy for preempting
                                pods with lower priority. One of Never, PreemptLowerPriority.
                                Defaults to PreemptLowerPriority if unset. This field
                                is beta-level, gated by the NonPreemptingPriority
                                feature-gate.
                              type: string
                            priority:
                              description: The priority value. Various system components
                                use this field to find the priority of the pod. When
                                Priority Admission Controller is enabled, it prevents
                                users from setting this field. The admission controller
                                populates this field from PriorityClassName. The higher
                                the value, the higher the priority.
                              format: int32
                              type: integer
                            priorityClassName:
                              description: If specified, indicates the pod's priority.
                                "system-node-critical" and "system-cluster-critical"
                                are two special keywords which indicate the highest
                                priorities with the former being the highest priority.
                                Any other name must be defined by creating a PriorityClass
                                object with that name. If not specified, the pod priority
                                will be default or zero if there is no default.
                              type: string
                            runtimeClassName:
                              description: 'RuntimeClassName refers to a RuntimeClass
                                object in the node.k8s.io group, which should be used
                                to run this pod.  If no RuntimeClass resource matches
                                the named class, the pod will not be run. If unset
                                or empty, the "legacy" RuntimeClass will be used,
                                which is an implicit class with an empty definition
                                that uses the default runtime handler. More info:
                                https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class
                                This is a beta feature as of Kubernetes v1.14.'
                              type: string
                            schedulerName:
                              description: If specified, the pod will be dispatched
                                by specified scheduler. If not specified, the pod
                                will be dispatched by default scheduler.
                              type: string
                            serviceAccount:
                              description: 'DeprecatedServiceAccount is a depreciated
                                alias for ServiceAccountName. Deprecated: Use serviceAccountName
                                instead.'
                              type: string
                            serviceAccountName:
                              description: 'ServiceAccountName is the name of the
                                ServiceAccount to use to run this pod. More info:
                                https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/'
                              type: string
                            setHostnameAsFQDN:
                              description: If true the pod's hostname will be configured
                                as the pod's FQDN, rather than the leaf name (the
                                default). In Linux containers, this means setting
                                the FQDN in the hostname field of the kernel (the
                                nodename field of struct utsname). In Windows containers,
                                this means setting the registry value of hostname
                                for the registry key HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters
                                to FQDN. If a pod does not have FQDN, this has no
                                effect. Default to false.
                              type: boolean
                            shareProcessNamespace:
                              description: 'Share a single process namespace between
                                all of the containers in a pod. When this is set containers
                                will be able to view and signal processes from other
                                containers in the same pod, and the first process
                                in each container will not be assigned PID 1. HostPID
                                and ShareProcessNamespace cannot both be set. Optional:
                                Default to false.'
                              type: boolean
                            terminationGracePeriodSeconds:
                              description: Optional duration in seconds the pod needs
                                to terminate gracefully. May be decreased in delete
                                request. Value must be non-negative integer. The value
                                zero indicates stop immediately via the kill signal
                                (no opportunity to shut down). If this value is nil,
                                the default grace period will be used instead. The
                                grace period is the duration in seconds after the
                                processes running in the pod are sent a termination
                                signal and the time when the processes are forcibly
                                halted with a kill signal. Set this value longer than
                                the expected cleanup time for your process. Defaults
                                to 30 seconds.
                              format: int64
                              type: integer
                            tolerations:
                              description: If specified, the pod's tolerations.
                              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
                            topologySpreadConstraints:
                              description: TopologySpreadConstraints describes how
                                a group of pods ought to spread across topology domains.
                                Scheduler will schedule pods in a way which abides
                                by the constraints. All topologySpreadConstraints
                                are ANDed.
                              items:
                                description: TopologySpreadConstraint specifies how
                                  to spread matching pods among the given topology.
                                properties:
                                  labelSelector:
                                    description: LabelSelector is used to find matching
                                      pods. Pods that match this label selector are
                                      counted to determine the number of pods in their
                                      corresponding topology domain.
                                    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
                                          required:
                                          - key
                                          - operator
                                          type: object
                                        type: array
                                      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
                                  maxSkew:
                                    description: 'MaxSkew describes the degree to
                                      which pods may be unevenly distributed. When
                                      `whenUnsatisfiable=DoNotSchedule`, it is the
                                      maximum permitted difference between the number
                                      of matching pods in the target topology and
                                      the global minimum. For example, in a 3-zone
                                      cluster, MaxSkew is set to 1, and pods with
                                      the same labelSelector spread as 1/1/0: | zone1
                                      | zone2 | zone3 | |   P   |   P   |       |
                                      - if MaxSkew is 1, incoming pod can only be
                                      scheduled to zone3 to become 1/1/1; scheduling
                                      it onto zone1(zone2) would make the ActualSkew(2-0)
                                      on zone1(zone2) violate MaxSkew(1). - if MaxSkew
                                      is 2, incoming pod can be scheduled onto any
                                      zone. When `whenUnsatisfiable=ScheduleAnyway`,
                                      it is used to give higher precedence to topologies
                                      that satisfy it. It''s a required field. Default
                                      value is 1 and 0 is not allowed.'
                                    format: int32
                                    type: integer
                                  topologyKey:
                                    description: TopologyKey is the key of node labels.
                                      Nodes that have a label with this key and identical
                                      values are considered to be in the same topology.
                                      We consider each <key, value> as a "bucket",
                                      and try to put balanced number of pods into
                                      each bucket. It's a required field.
                                    type: string
                                  whenUnsatisfiable:
                                    description: 'WhenUnsatisfiable indicates how
                                      to deal with a pod if it doesn''t satisfy the
                                      spread constraint. - DoNotSchedule (default)
                                      tells the scheduler not to schedule it. - ScheduleAnyway
                                      tells the scheduler to schedule the pod in any
                                      location, but giving higher precedence to topologies
                                      that would help reduce the skew. A constraint
                                      is considered "Unsatisfiable" for an incoming
                                      pod if and only if every possible node assignment
                                      for that pod would violate "MaxSkew" on some
                                      topology. For example, in a 3-zone cluster,
                                      MaxSkew is set to 1, and pods with the same
                                      labelSelector spread as 3/1/1: | zone1 | zone2
                                      | zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable
                                      is set to DoNotSchedule, incoming pod can only
                                      be scheduled to zone2(zone3) to become 3/2/1(3/1/2)
                                      as ActualSkew(2-1) on zone2(zone3) satisfies
                                      MaxSkew(1). In other words, the cluster can
                                      still be imbalanced, but scheduler won''t make
                                      it *more* imbalanced. It''s a required field.'
                                    type: string
                                required:
                                - maxSkew
                                - topologyKey
                                - whenUnsatisfiable
                                type: object
                              type: array
                              x-kubernetes-list-map-keys:
                              - topologyKey
                              - whenUnsatisfiable
                              x-kubernetes-list-type: map
                          type: object
                      type: object
                    resources:
                      description: Resources are the resource requirements for the
                        Couchbase server container. This field overrides any automatic
                        allocation as defined by `spec.autoResourceAllocation`.
                      properties:
                        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. More info:
                            https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                          type: object
                      type: object
                    serverGroups:
                      description: ServerGroups define the set of availability zones
                        you want to distribute pods over, and construct Couchbase
                        server groups for.  By default, most cloud providers will
                        label nodes with the key "topology.kubernetes.io/zone", the
                        values associated with that key are used here to provide explicit
                        scheduling by the Operator.  You may manually label nodes
                        using the "topology.kubernetes.io/zone" key, to provide failure-domain
                        aware scheduling when none is provided for you.  Global server
                        groups are applied to all server classes, and may be overridden
                        on a per-server class basis to give more control over scheduling
                        and server groups.
                      items:
                        type: string
                      type: array
                      x-kubernetes-list-type: set
                    services:
                      description: Services is the set of Couchbase services to run
                        on this server class. At least one class must contain the
                        data service.  The field may contain any of "data", "index",
                        "query", "search", "eventing" or "analytics". Each service
                        may only be specified once.
                      items:
                        description: Supported services
                        enum:
                        - admin
                        - data
                        - index
                        - query
                        - search
                        - eventing
                        - analytics
                        type: string
                      type: array
                      x-kubernetes-list-type: set
                    size:
                      description: Size is the expected requested of the server class.  This
                        field must be greater than or equal to 1.
                      minimum: 1
                      type: integer
                    volumeMounts:
                      description: VolumeMounts define persistent volume claims to
                        attach to pod.
                      properties:
                        analytics:
                          description: AnalyticsClaims are persistent volumes that
                            encompass analytics storage associated with the analytics
                            service.  Analytics claims can only be used on server
                            classes running the analytics service, and must be used
                            in conjunction with the default claim. This field allows
                            the analytics service to use different storage media (e.g.
                            SSD), and scale horizontally, to improve performance of
                            this service.  This field references a volume claim template
                            name as defined in "spec.volumeClaimTemplates".
                          items:
                            type: string
                          type: array
                        data:
                          description: DataClaim is a persistent volume that encompasses
                            key/value storage associated with the data service.  The
                            data claim can only be used on server classes running
                            the data service, and must be used in conjunction with
                            the default claim.  This field allows the data service
                            to use different storage media (e.g. SSD) to improve performance
                            of this service.  This field references a volume claim
                            template name as defined in "spec.volumeClaimTemplates".
                          type: string
                        default:
                          description: DefaultClaim is a persistent volume that encompasses
                            all Couchbase persistent data, including document storage,
                            indexes and logs.  The default volume can be used with
                            any server class.  Use of the default claim allows the
                            Operator to recover failed pods from the persistent volume
                            far quicker than if the pod were using ephemeral storage.  The
                            default claim cannot be used at the same time as the logs
                            claim within the same server class.  This field references
                            a volume claim template name as defined in "spec.volumeClaimTemplates".
                          type: string
                        index:
                          description: IndexClaim s a persistent volume that encompasses
                            index storage associated with the index and search services.  The
                            index claim can only be used on server classes running
                            the index or search services, and must be used in conjunction
                            with the default claim.  This field allows the index and/or
                            search service to use different storage media (e.g. SSD)
                            to improve performance of this service. This field references
                            a volume claim template name as defined in "spec.volumeClaimTemplates".
                            Whilst this references index primarily, note that the
                            full text search (FTS) service also uses this same mount.
                          type: string
                        logs:
                          description: 'LogsClaim is a persistent volume that encompasses
                            only Couchbase server logs to aid with supporting the
                            product.  The logs claim can only be used on server classes
                            running the following services: query, search & eventing.  The
                            logs claim cannot be used at the same time as the default
                            claim within the same server class.  This field references
                            a volume claim template name as defined in "spec.volumeClaimTemplates".
                            Whilst the logs claim can be used with the search service,
                            the recommendation is to use the default claim for these.
                            The reason for this is that a failure of these nodes will
                            require indexes to be rebuilt and subsequent performance
                            impact.'
                          type: string
                      type: object
                  required:
                  - name
                  - services
                  - size
                  type: object
                minItems: 1
                type: array
                x-kubernetes-list-map-keys:
                - name
                x-kubernetes-list-type: map
              softwareUpdateNotifications:
                description: SoftwareUpdateNotifications enables software update notifications
                  in the UI. When enabled, the UI will alert when a Couchbase server
                  upgrade is available.
                type: boolean
              upgradeStrategy:
                description: UpgradeStrategy controls how aggressive the Operator
                  is when performing a cluster upgrade.  When a rolling upgrade is
                  requested, pods are upgraded one at a time.  This strategy is slower,
                  however less disruptive.  When an immediate upgrade strategy is
                  requested, all pods are upgraded at the same time.  This strategy
                  is faster, but more disruptive.  This field must be either "RollingUpgrade"
                  or "ImmediateUpgrade", defaulting to "RollingUpgrade".
                enum:
                - RollingUpgrade
                - ImmediateUpgrade
                type: string
              volumeClaimTemplates:
                description: VolumeClaimTemplates define the desired characteristics
                  of a volume that can be requested/claimed by a pod, for example
                  the storage class to use and the volume size.  Volume claim templates
                  are referred to by name by server class volume mount configuration.
                items:
                  properties:
                    metadata:
                      description: Standard objects metadata.  This is a curated version
                        for use with Couchbase resource templates.
                      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
                        name:
                          description: 'Name must be unique within a namespace. Is
                            required when creating resources, although some resources
                            may allow a client to request the generation of an appropriate
                            name automatically. Name is primarily intended for creation
                            idempotence and configuration definition. Cannot be updated.
                            More info: http://kubernetes.io/docs/user-guide/identifiers#names'
                          type: string
                      required:
                      - name
                      type: object
                    spec:
                      description: PersistentVolumeClaimSpec describes the common
                        attributes of storage devices and allows a Source for provider-specific
                        attributes
                      properties:
                        accessModes:
                          description: 'AccessModes contains the desired access modes
                            the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1'
                          items:
                            type: string
                          type: array
                        dataSourceRef:
                          description: 'Specifies the object from which to populate
                            the volume with data, if a non-empty volume is desired.
                            This may be any local object from a non-empty API group
                            (non core object) or a PersistentVolumeClaim object. When
                            this field is specified, volume binding will only succeed
                            if the type of the specified object matches some installed
                            volume populator or dynamic provisioner. This field will
                            replace the functionality of the DataSource field and
                            as such if both fields are non-empty, they must have the
                            same value. For backwards compatibility, both fields (DataSource
                            and DataSourceRef) will be set to the same value automatically
                            if one of them is empty and the other is non-empty. There
                            are two important differences between DataSource and DataSourceRef:
                            * While DataSource only allows two specific types of objects,
                            DataSourceRef allows any non-core object, as well as PersistentVolumeClaim
                            objects. * While DataSource ignores disallowed values
                            (dropping them), DataSourceRef preserves all values, and
                            generates an error if a disallowed value is specified.
                            (Alpha) Using this field requires the AnyVolumeDataSource
                            feature gate to be enabled.'
                          properties:
                            apiGroup:
                              description: APIGroup is the group for the resource
                                being referenced. If APIGroup is not specified, the
                                specified Kind must be in the core API group. For
                                any other third-party types, APIGroup is required.
                              type: string
                            kind:
                              description: Kind is the type of resource being referenced
                              type: string
                            name:
                              description: Name is the name of resource being referenced
                              type: string
                          required:
                          - kind
                          - name
                          type: object
                        resources:
                          description: 'Resources represents the minimum resources
                            the volume should have. If RecoverVolumeExpansionFailure
                            feature is enabled users are allowed to specify resource
                            requirements that are lower than previous value but must
                            still be higher than capacity recorded in the status field
                            of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources'
                          properties:
                            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. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                              type: object
                          type: object
                        selector:
                          description: A label query over volumes to consider for
                            binding.
                          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
                                required:
                                - key
                                - operator
                                type: object
                              type: array
                            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
                        storageClassName:
                          description: 'Name of the StorageClass required by the claim.
                            More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1'
                          type: string
                        volumeMode:
                          description: volumeMode defines what type of volume is required
                            by the claim. Value of Filesystem is implied when not
                            included in claim spec.
                          type: string
                        volumeName:
                          description: VolumeName is the binding reference to the
                            PersistentVolume backing this claim.
                          type: string
                      type: object
                  required:
                  - metadata
                  - spec
                  type: object
                type: array
              xdcr:
                description: XDCR defines whether the Operator should manage XDCR,
                  remote clusters and how to lookup replication resources.
                properties:
                  managed:
                    description: Managed defines whether XDCR is managed by the operator
                      or not.
                    type: boolean
                  remoteClusters:
                    description: RemoteClusters is a set of named remote clusters
                      to establish replications to.
                    items:
                      description: RemoteCluster is a reference to a remote cluster
                        for XDCR.
                      properties:
                        authenticationSecret:
                          description: AuthenticationSecret is a secret used to authenticate
                            when establishing a remote connection.  It is only required
                            when not using mTLS.  The secret must contain a username
                            (secret key "username") and password (secret key "password").
                          type: string
                        hostname:
                          description: Hostname is the connection string to use to
                            connect the remote cluster.
                          pattern: ^((couchbase|couchbases|http|https)://)?[0-9a-zA-Z\-\.]+(:\d+)?(\?network=[^&]+)?$
                          type: string
                        name:
                          description: Name of the remote cluster.
                          type: string
                        replications:
                          description: Replications are replication streams from this
                            cluster to the remote one. This field defines how to look
                            up CouchbaseReplication resources.  By default any CouchbaseReplication
                            resources in the namespace will be considered.
                          properties:
                            selector:
                              description: Selector allows CouchbaseReplication resources
                                to be filtered based on labels.
                              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
                                    required:
                                    - key
                                    - operator
                                    type: object
                                  type: array
                                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
                          type: object
                        tls:
                          description: TLS if specified references a resource containing
                            the necessary certificate data for an encrypted connection.
                          properties:
                            secret:
                              description: Secret references a secret containing the
                                CA certificate (data key "ca"), and optionally a client
                                certificate (data key "certificate") and key (data
                                key "key").
                              type: string
                          required:
                          - secret
                          type: object
                        uuid:
                          description: UUID of the remote cluster.  The UUID of a
                            CouchbaseCluster resource is advertised in the status.clusterId
                            field of the resource.
                          pattern: ^[0-9a-f]{32}$
                          type: string
                      required:
                      - hostname
                      - name
                      - uuid
                      type: object
                    type: array
                    x-kubernetes-list-map-keys:
                    - name
                    x-kubernetes-list-type: map
                type: object
            required:
            - image
            - security
            - servers
            type: object
          status:
            description: ClusterStatus defines any read-only status fields for the
              Couchbase server cluster.
            properties:
              allocations:
                description: Allocations shows memory allocations within server classes.
                items:
                  description: ServerClassStatus summarizes memory allocations to
                    make configuration easier.
                  properties:
                    allocatedMemory:
                      anyOf:
                      - type: integer
                      - type: string
                      description: 'AllocatedMemory defines the total memory allocated
                        for constrained Couchbase services. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      type: string
                      x-kubernetes-int-or-string: true
                    allocatedMemoryPercent:
                      description: AllocatedMemoryPercent is set when memory resources
                        are requested and define how much of the requested memory
                        is allocated to constrained Couchbase services.
                      type: integer
                    analyticsServiceAllocation:
                      anyOf:
                      - type: integer
                      - type: string
                      description: 'AnalyticsServiceAllocation is set when the analytics
                        service is enabled for this class and defines how much memory
                        this service consumes per pod.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      type: string
                      x-kubernetes-int-or-string: true
                    dataServiceAllocation:
                      anyOf:
                      - type: integer
                      - type: string
                      description: 'DataServiceAllocation is set when the data service
                        is enabled for this class and defines how much memory this
                        service consumes per pod.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      type: string
                      x-kubernetes-int-or-string: true
                    eventingServiceAllocation:
                      anyOf:
                      - type: integer
                      - type: string
                      description: 'EventingServiceAllocation is set when the eventing
                        service is enabled for this class and defines how much memory
                        this service consumes per pod.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      type: string
                      x-kubernetes-int-or-string: true
                    indexServiceAllocation:
                      anyOf:
                      - type: integer
                      - type: string
                      description: 'IndexServiceAllocation is set when the index service
                        is enabled for this class and defines how much memory this
                        service consumes per pod.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      type: string
                      x-kubernetes-int-or-string: true
                    name:
                      description: Name is the name of the server class defined in
                        spec.servers
                      type: string
                    requestedMemory:
                      anyOf:
                      - type: integer
                      - type: string
                      description: 'RequestedMemory, if set, defines the Kubernetes
                        resource request for the server class. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      type: string
                      x-kubernetes-int-or-string: true
                    searchServiceAllocation:
                      anyOf:
                      - type: integer
                      - type: string
                      description: 'SearchServiceAllocation is set when the search
                        service is enabled for this class and defines how much memory
                        this service consumes per pod.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      type: string
                      x-kubernetes-int-or-string: true
                    unusedMemory:
                      anyOf:
                      - type: integer
                      - type: string
                      description: 'UnusedMemory is set when memory resources are
                        requested and is the difference between the requestedMemory
                        and allocatedMemory.  More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#resource-units-in-kubernetes'
                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                      type: string
                      x-kubernetes-int-or-string: true
                    unusedMemoryPercent:
                      description: UnusedMemoryPercent is set when memory resources
                        are requested and defines how much requested memory is not
                        allocated.  Couchbase server expects at least a 20% overhead.
                      type: integer
                  required:
                  - name
                  type: object
                type: array
              autoscalers:
                description: Autscalers describes all the autoscalers managed by the
                  cluster.
                items:
                  type: string
                type: array
              buckets:
                description: Buckets describes all the buckets managed by the cluster.
                items:
                  properties:
                    compressionMode:
                      description: CompressionMode defines how documents are compressed.
                      type: string
                    conflictResolution:
                      description: ConflictResolution is relevant for `couchbase`
                        and `ephemeral` bucket types and indicates how to resolve
                        conflicts when using multi-master XDCR.
                      type: string
                    enableFlush:
                      description: EnableFlush is whether a client can delete all
                        documents in a bucket.
                      type: boolean
                    enableIndexReplica:
                      description: EnableIndexReplica is whether indexes against bucket
                        documents are replicated.
                      type: boolean
                    evictionPolicy:
                      description: EvictionPolicy is relevant for `couchbase` and
                        `ephemeral` bucket types and indicates how documents are evicted
                        from memory when it is exhausted.
                      type: string
                    ioPriority:
                      description: IoPriority is `low` or `high` depending on the
                        number of threads spawned for data processing.
                      type: string
                    memoryQuota:
                      description: BucketMemoryQuota is the bucket memory quota in
                        megabytes.
                      format: int64
                      type: integer
                    name:
                      description: BucketName is the full name of the bucket.
                      type: string
                    password:
                      description: BucketPassword will never be populated.
                      type: string
                    replicas:
                      description: BucketReplicas is the number of data replicas.
                      type: integer
                    type:
                      description: BucketType is the type of the bucket.
                      type: string
                  required:
                  - compressionMode
                  - conflictResolution
                  - enableFlush
                  - enableIndexReplica
                  - evictionPolicy
                  - ioPriority
                  - memoryQuota
                  - name
                  - password
                  - replicas
                  - type
                  type: object
                type: array
              clusterId:
                description: ClusterID is the unique cluster UUID.  This is generated
                  every time a new cluster is created, so may vary over the lifetime
                  of a cluster if it is recreated by disaster recovery mechanisms.
                type: string
              conditions:
                description: Current service state of the Couchbase cluster.
                items:
                  properties:
                    lastTransitionTime:
                      description: Last time the condition transitioned from one status
                        to another.
                      type: string
                    lastUpdateTime:
                      description: Last time the condition status message updated.
                      type: string
                    message:
                      description: A human readable message indicating details about
                        the transition.
                      type: string
                    reason:
                      description: Unique, one-word, CamelCase reason for the condition's
                        last transition.
                      type: string
                    status:
                      description: Status is the status of the condition. Can be one
                        of True, False, Unknown.
                      type: string
                    type:
                      description: Type is the type of condition.
                      enum:
                      - Available
                      - Balanced
                      - ManageConfig
                      - Scaling
                      - ScalingUp
                      - ScalingDown
                      - Upgrading
                      - Hibernating
                      - Error
                      - AutoscaleReady
                      - Synchronized
                      type: string
                  required:
                  - status
                  - type
                  type: object
                type: array
              controlPaused:
                description: ControlPaused indicates if the Operator has acknowledged
                  and paused the control of the cluster.
                type: boolean
              currentVersion:
                description: CurrentVersion is the current Couchbase version.  This
                  reflects the version of the whole cluster, therefore during upgrade,
                  it is only updated when the upgrade has completed.
                type: string
              groups:
                description: Groups describes all the groups managed by the cluster.
                items:
                  type: string
                type: array
              members:
                description: Members are the Couchbase members in the cluster.
                properties:
                  ready:
                    description: Ready are the Couchbase members that are clustered
                      and ready to serve client requests.  The member names are the
                      same as the Couchbase pod names.
                    items:
                      type: string
                    type: array
                  unready:
                    description: Unready are the Couchbase members not clustered or
                      unready to serve client requests.  The member names are the
                      same as the Couchbase pod names.
                    items:
                      type: string
                    type: array
                type: object
              size:
                description: Size is the current size of the cluster in terms of pods.  Individual
                  pod status conditions are listed in the members status.
                type: integer
              users:
                description: Users describes all the users managed by the cluster.
                items:
                  type: string
                type: array
            required:
            - size
            type: object
        required:
        - spec
        type: object
    served: true
    storage: true
