operations.kubeblocks.io_opsrequests.yaml

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.18.0
  labels:
    app.kubernetes.io/name: kubeblocks
  name: opsrequests.operations.kubeblocks.io
spec:
  group: operations.kubeblocks.io
  names:
    categories:
    - kubeblocks
    kind: OpsRequest
    listKind: OpsRequestList
    plural: opsrequests
    shortNames:
    - ops
    singular: opsrequest
  scope: Namespaced
  versions:
  - additionalPrinterColumns:
    - description: Operation request type.
      jsonPath: .spec.type
      name: TYPE
      type: string
    - description: Operand cluster.
      jsonPath: .spec.clusterName
      name: CLUSTER
      type: string
    - description: Operation status phase.
      jsonPath: .status.phase
      name: STATUS
      type: string
    - description: Operation processing progress.
      jsonPath: .status.progress
      name: PROGRESS
      type: string
    - jsonPath: .metadata.creationTimestamp
      name: AGE
      type: date
    name: v1alpha1
    schema:
      openAPIV3Schema:
        description: OpsRequest is the Schema for the opsrequests API
        properties:
          apiVersion:
            description: |-
              APIVersion defines the versioned schema of this representation of an object.
              Servers should convert recognized schemas to the latest internal value, and
              may reject unrecognized values.
              More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
            type: string
          kind:
            description: |-
              Kind is a string value representing the REST resource this object represents.
              Servers may infer this from the endpoint the client submits requests to.
              Cannot be updated.
              In CamelCase.
              More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
            type: string
          metadata:
            type: object
          spec:
            description: OpsRequestSpec defines the desired state of OpsRequest
            properties:
              backup:
                description: Specifies the parameters to back up a Cluster.
                properties:
                  backupMethod:
                    description: |-
                      Specifies the name of BackupMethod.
                      The specified BackupMethod must be defined in the BackupPolicy.
                    type: string
                  backupName:
                    description: Specifies the name of the Backup custom resource.
                    type: string
                  backupPolicyName:
                    description: Indicates the name of the BackupPolicy applied to
                      perform this Backup.
                    type: string
                  deletionPolicy:
                    default: Delete
                    description: |-
                      Determines whether the backup contents stored in backup repository
                      should be deleted when the Backup custom resource is deleted.
                      Supported values are `Retain` and `Delete`.
                      - `Retain` means that the backup content and its physical snapshot on backup repository are kept.
                      - `Delete` means that the backup content and its physical snapshot on backup repository are deleted.
                    enum:
                    - Delete
                    - Retain
                    type: string
                  parameters:
                    description: |-
                      Specifies a list of name-value pairs representing parameters and their corresponding values.
                      Parameters match the schema specified in the `actionset.spec.parametersSchema`
                    items:
                      properties:
                        name:
                          description: Represents the name of the parameter.
                          type: string
                        value:
                          description: Represents the parameter values.
                          type: string
                      required:
                      - name
                      - value
                      type: object
                    maxItems: 128
                    type: array
                    x-kubernetes-list-map-keys:
                    - name
                    x-kubernetes-list-type: map
                    x-kubernetes-validations:
                    - message: forbidden to update parameters
                      rule: self == oldSelf
                  parentBackupName:
                    description: If the specified BackupMethod is incremental, `parentBackupName`
                      is required.
                    type: string
                  retentionPeriod:
                    description: |-
                      Determines the duration for which the Backup custom resources should be retained.

                      The controller will automatically remove all Backup objects that are older than the specified RetentionPeriod.
                      For example, RetentionPeriod of `30d` will keep only the Backup objects of last 30 days.
                      Sample duration format:

                      - years: 2y
                      - months: 6mo
                      - days: 30d
                      - hours: 12h
                      - minutes: 30m

                      You can also combine the above durations. For example: 30d12h30m.
                      If not set, the Backup objects will be kept forever.

                      If the `deletionPolicy` is set to 'Delete', then the associated backup data will also be deleted
                      along with the Backup object.
                      Otherwise, only the Backup custom resource will be deleted.
                    type: string
                type: object
                x-kubernetes-validations:
                - message: forbidden to update backup.parameters
                  rule: has(oldSelf.parameters) == has(self.parameters)
              cancel:
                description: |-
                  Indicates whether the current operation should be canceled and terminated gracefully if it's in the
                  "Pending", "Creating", or "Running" state.

                  This field applies only to "VerticalScaling" and "HorizontalScaling" opsRequests.

                  Note: Setting `cancel` to true is irreversible; further modifications to this field are ineffective.
                type: boolean
              clusterName:
                description: Specifies the name of the Cluster resource that this
                  operation is targeting.
                type: string
                x-kubernetes-validations:
                - message: forbidden to update spec.clusterName
                  rule: self == oldSelf
              custom:
                description: Specifies a custom operation defined by OpsDefinition.
                properties:
                  components:
                    description: |-
                      Specifies the components and their parameters for executing custom actions as defined in OpsDefinition.
                      Requires at least one component.
                    items:
                      properties:
                        componentName:
                          description: Specifies the name of the Component as defined
                            in the cluster.spec
                          type: string
                        parameters:
                          description: Specifies the parameters that match the schema
                            specified in the `opsDefinition.spec.parametersSchema`.
                          items:
                            properties:
                              name:
                                description: Specifies the identifier of the parameter
                                  as defined in the OpsDefinition.
                                type: string
                              value:
                                description: |-
                                  Holds the data associated with the parameter.
                                  If the parameter type is an array, the format should be "v1,v2,v3".
                                type: string
                              valueFrom:
                                description: Source for the parameter'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
                                        type: string
                                      optional:
                                        description: Specify whether the ConfigMap
                                          or its key must be defined
                                        type: boolean
                                    required:
                                    - key
                                    type: object
                                    x-kubernetes-map-type: atomic
                                  secretKeyRef:
                                    description: Selects a key of a Secret.
                                    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
                                        type: string
                                      optional:
                                        description: Specify whether the Secret or
                                          its key must be defined
                                        type: boolean
                                    required:
                                    - key
                                    type: object
                                    x-kubernetes-map-type: atomic
                                type: object
                            required:
                            - name
                            - value
                            type: object
                          type: array
                          x-kubernetes-list-map-keys:
                          - name
                          x-kubernetes-list-type: map
                      required:
                      - componentName
                      type: object
                    maxItems: 1024
                    minItems: 1
                    type: array
                    x-kubernetes-list-map-keys:
                    - componentName
                    x-kubernetes-list-type: map
                  maxConcurrentComponents:
                    anyOf:
                    - type: integer
                    - type: string
                    description: |-
                      Specifies the maximum number of components to be operated on concurrently to mitigate performance impact
                      on clusters with multiple components.

                      It accepts an absolute number (e.g., 5) or a percentage of components to execute in parallel (e.g., "10%").
                      Percentages are rounded up to the nearest whole number of components.
                      For example, if "10%" results in less than one, it rounds up to 1.

                      When unspecified, all components are processed simultaneously by default.

                      Note: This feature is not implemented yet.
                    x-kubernetes-int-or-string: true
                  opsDefinitionName:
                    description: Specifies the name of the OpsDefinition.
                    type: string
                  serviceAccountName:
                    description: Specifies the name of the ServiceAccount to be used
                      for executing the custom operation.
                    type: string
                required:
                - components
                - opsDefinitionName
                type: object
              enqueueOnForce:
                default: false
                description: Indicates whether opsRequest should continue to queue
                  when 'force' is set to true.
                type: boolean
              expose:
                description: Lists Expose objects, each specifying a Component and
                  its services to be exposed.
                items:
                  properties:
                    componentName:
                      description: Specifies the name of the Component.
                      type: string
                    services:
                      description: |-
                        Specifies a list of OpsService.
                        When an OpsService is exposed, a corresponding ClusterService will be added to `cluster.spec.services`.
                        On the other hand, when an OpsService is unexposed, the corresponding ClusterService will be removed
                        from `cluster.spec.services`.

                        Note: If `componentName` is not specified, the `ports` and `selector` fields must be provided
                        in each OpsService definition.
                      items:
                        description: OpsService represents the parameters to dynamically
                          create or remove a ClusterService in the `cluster.spec.services`
                          array.
                        properties:
                          annotations:
                            additionalProperties:
                              type: string
                            description: |-
                              Contains cloud provider related parameters if ServiceType is LoadBalancer.

                              More info: https://kubernetes.io/docs/concepts/services-networking/service/#loadbalancer.
                            type: object
                          externalTrafficPolicy:
                            description: |-
                              Specifies the external traffic policy of the Service. This controls how external traffic is routed to node-local or cluster-wide endpoints.

                              Possible values:

                              - `Cluster` (default for NodePort): Routes external traffic to all ready endpoints of the Service.
                                This preserves the original source IP and avoids a second hop for LoadBalancer and NodePort services.
                              - `Local`: Routes external traffic only to node-local endpoints.
                                If no node-local endpoints exist, traffic is dropped. This ensures that the source IP is exposed.

                              This field is only applicable to LoadBalancer and NodePort services.
                            type: string
                          internalTrafficPolicy:
                            description: |-
                              Specifies the internal traffic policy of the Service. This controls how traffic from internal sources
                              is routed.

                              Possible values:

                              - `Cluster` (default): Routes internal traffic to all ready endpoints of the Service.
                                This distributes traffic evenly across all endpoints.
                              - `Local`: Routes internal traffic only to node-local endpoints.
                                If no node-local endpoints exist, traffic is dropped.

                              This field can be specified on any Service type.
                            type: string
                          ipFamilies:
                            description: |-
                              A list of IP families (e.g., IPv4, IPv6) assigned to this Service.

                              Usually assigned automatically based on the cluster configuration and the `ipFamilyPolicy` field.
                              If specified manually, the requested IP family must be available in the cluster and allowed by the `ipFamilyPolicy`.
                              If the requested IP family is not available or not allowed, the Service creation will fail.

                              Valid values:

                              - "IPv4"
                              - "IPv6"

                              This field may hold a maximum of two entries (dual-stack families, in either order).

                              Common combinations of `ipFamilies` and `ipFamilyPolicy` are:

                              - ipFamilies=[] + ipFamilyPolicy="PreferDualStack" :
                                The Service prefers dual-stack but can fall back to single-stack if the cluster does not support dual-stack.
                                The IP family is automatically assigned based on the cluster configuration.
                              - ipFamilies=["IPV4","IPV6"] + ipFamilyPolicy="RequiredDualStack" :
                                The Service requires dual-stack and will only be created if the cluster supports both IPv4 and IPv6.
                                The primary IP family is IPV4.
                              - ipFamilies=["IPV6","IPV4"] + ipFamilyPolicy="RequiredDualStack" :
                                The Service requires dual-stack and will only be created if the cluster supports both IPv4 and IPv6.
                                The primary IP family is IPV6.
                              - ipFamilies=["IPV4"] + ipFamilyPolicy="SingleStack" :
                                The Service uses a single-stack with IPv4 only.
                              - ipFamilies=["IPV6"] + ipFamilyPolicy="SingleStack" :
                                The Service uses a single-stack with IPv6 only.
                            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: |-
                              Specifies whether the Service should use a single IP family (SingleStack) or two IP families (DualStack).

                              Possible values:

                              - 'SingleStack' (default) : The Service uses a single IP family.
                                If no value is provided, IPFamilyPolicy defaults to SingleStack.
                              - 'PreferDualStack' : The Service prefers to use two IP families on dual-stack configured clusters
                                or a single IP family on single-stack clusters.
                              - 'RequiredDualStack' : The Service requires two IP families on dual-stack configured clusters.
                                If the cluster is not configured for dual-stack, the Service creation fails.
                            type: string
                          name:
                            description: |-
                              Specifies the name of the Service. This name is used to set `clusterService.name`.

                              Note: This field cannot be updated.
                            type: string
                          podSelector:
                            additionalProperties:
                              type: string
                            description: |-
                              Routes service traffic to pods with matching label keys and values.
                              If specified, the service will only be exposed to pods matching the selector.

                              Note: If the component has roles, at least one of 'roleSelector' or 'podSelector' must be specified.
                              If both are specified, a pod must match both conditions to be selected.
                            type: object
                            x-kubernetes-map-type: atomic
                          ports:
                            description: |-
                              Specifies Port definitions that are to be exposed by a ClusterService.

                              If not specified, the Port definitions from non-NodePort and non-LoadBalancer type ComponentService
                              defined in the ComponentDefinition (`componentDefinition.spec.services`) will be used.
                              If no matching ComponentService is found, the expose operation will fail.

                              More info: https://kubernetes.io/docs/concepts/services-networking/service/#field-spec-ports
                            items:
                              description: ServicePort contains information on service's
                                port.
                              properties:
                                appProtocol:
                                  description: |-
                                    The application protocol for this port.
                                    This is used as a hint for implementations to offer richer behavior for protocols that they understand.
                                    This field follows standard Kubernetes label syntax.
                                    Valid values are either:

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

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

                                    * Other protocols should use implementation-defined prefixed names such as
                                    mycompany.com/my-custom-protocol.
                                  type: string
                                name:
                                  description: |-
                                    The name of this port within the service. This must be a DNS_LABEL.
                                    All ports within a ServiceSpec must have unique names. When considering
                                    the endpoints for a Service, this must match the 'name' field in the
                                    EndpointPort.
                                    Optional if only one ServicePort is defined on this service.
                                  type: string
                                nodePort:
                                  description: |-
                                    The port on each node on which this service is exposed when type is
                                    NodePort or LoadBalancer.  Usually assigned by the system. If a value is
                                    specified, in-range, and not in use it will be used, otherwise the
                                    operation will fail.  If not specified, a port will be allocated if this
                                    Service requires one.  If this field is specified when creating a
                                    Service which does not need it, creation will fail. This field will be
                                    wiped when updating a Service to no longer need it (e.g. changing type
                                    from NodePort to ClusterIP).
                                    More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport
                                  format: int32
                                  type: integer
                                port:
                                  description: The port that will be exposed by this
                                    service.
                                  format: int32
                                  type: integer
                                protocol:
                                  default: TCP
                                  description: |-
                                    The IP protocol for this port. Supports "TCP", "UDP", and "SCTP".
                                    Default is TCP.
                                  type: string
                                targetPort:
                                  anyOf:
                                  - type: integer
                                  - type: string
                                  description: |-
                                    Number or name of the port to access on the pods targeted by the service.
                                    Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
                                    If this is a string, it will be looked up as a named port in the
                                    target Pod's container ports. If this is not specified, the value
                                    of the 'port' field is used (an identity map).
                                    This field is ignored for services with clusterIP=None, and should be
                                    omitted or set equal to the 'port' field.
                                    More info: https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service
                                  x-kubernetes-int-or-string: true
                              required:
                              - port
                              type: object
                            type: array
                            x-kubernetes-list-map-keys:
                            - port
                            - protocol
                            x-kubernetes-list-type: map
                          roleSelector:
                            description: |-
                              Specifies a role to target with the service.
                              If specified, the service will only be exposed to pods with the matching role.

                              Note: If the component has roles, at least one of 'roleSelector' or 'podSelector' must be specified.
                              If both are specified, a pod must match both conditions to be selected.
                            type: string
                          serviceType:
                            description: |-
                              Determines how the Service is exposed. Defaults to 'ClusterIP'.
                              Valid options are `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,
                                 they are determined by manual construction of an Endpoints object or EndpointSlice objects.
                              - `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.

                              Note: although K8s Service type allows the 'ExternalName' type, it is not a valid option for the expose operation.

                              For more info, see:
                              https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types.
                            type: string
                        required:
                        - name
                        type: object
                      type: array
                    switch:
                      description: |-
                        Indicates whether the services will be exposed.
                        'Enable' exposes the services. while 'Disable' removes the exposed Service.
                      enum:
                      - Enable
                      - Disable
                      type: string
                  required:
                  - services
                  - switch
                  type: object
                type: array
              force:
                description: |-
                  Instructs the system to bypass pre-checks (including cluster state checks and customized pre-conditions hooks)
                  and immediately execute the opsRequest, except for the opsRequest of 'Start' type, which will still undergo
                  pre-checks even if `force` is true.

                  This is useful for concurrent execution of 'VerticalScaling' and 'HorizontalScaling' opsRequests.
                  By setting `force` to true, you can bypass the default checks and demand these opsRequests to run
                  simultaneously.

                  Note: Once set, the `force` field is immutable and cannot be updated.
                type: boolean
                x-kubernetes-validations:
                - message: forbidden to update spec.force
                  rule: self == oldSelf
              horizontalScaling:
                description: |-
                  Lists HorizontalScaling objects, each specifying scaling requirements for a Component,
                  including desired replica changes, configurations for new instances, modifications for existing instances,
                  and take offline/online the specified instances.
                items:
                  description: HorizontalScaling defines the parameters of a horizontal
                    scaling operation.
                  properties:
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec
                      type: string
                    scaleIn:
                      description: |-
                        Specifies the replica changes for scaling in components and instance templates,
                        and takes specified instances offline. Can be used in conjunction with the "scaleOut" operation.
                        Note: Any configuration that creates instances is considered invalid.
                      properties:
                        instances:
                          description: |-
                            Modifies the desired replicas count for existing InstanceTemplate.
                            if the inst
                          items:
                            description: InstanceReplicasTemplate defines the template
                              for instance replicas.
                            properties:
                              name:
                                description: Specifies the name of the instance template.
                                type: string
                              replicaChanges:
                                description: Specifies the replica changes for the
                                  instance template.
                                format: int32
                                minimum: 0
                                type: integer
                            required:
                            - name
                            - replicaChanges
                            type: object
                          type: array
                          x-kubernetes-list-map-keys:
                          - name
                          x-kubernetes-list-type: map
                        onlineInstancesToOffline:
                          description: Specifies the instance names that need to be
                            taken offline.
                          items:
                            type: string
                          type: array
                        replicaChanges:
                          description: Specifies the replica changes for the component.
                          format: int32
                          minimum: 0
                          type: integer
                      type: object
                    scaleOut:
                      description: |-
                        Specifies the replica changes for scaling out components and instance templates,
                        and brings offline instances back online. Can be used in conjunction with the "scaleIn" operation.
                        Note: Any configuration that deletes instances is considered invalid.
                      properties:
                        fromBackup:
                          description: |-
                            FromBackup specifies the configuration for creating new instances from an existing backup.
                            This is only effective for non-sharding components.
                            When specified, new instances will be created using data from the specified backup.
                          properties:
                            name:
                              description: Specifies the name of the Backup name.
                              type: string
                            namespace:
                              description: |-
                                Specifies the namespace of the Backup.
                                If not specified, the namespace of the OpsRequest will be used.
                                Cross-namespace VolumeSnapshot restores are NOT supported.
                              type: string
                            restoreEnv:
                              description: |-
                                Defines container environment variables for the restore process.
                                merged with the ones specified in the Backup and ActionSet resources.

                                Merge priority: Restore env > Backup env > ActionSet env.

                                Purpose: Some databases require different configurations when being restored as a standby
                                compared to being restored as a primary.
                                For example, when restoring MySQL as a replica, you need to set `skip_slave_start="ON"` for 5.7
                                or `skip_replica_start="ON"` for 8.0.
                                Allowing environment variables to be passed in makes it more convenient to control these behavioral differences
                                during the restore process.
                              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
                                            type: string
                                          optional:
                                            description: Specify whether the ConfigMap
                                              or its key must be defined
                                            type: boolean
                                        required:
                                        - key
                                        type: object
                                        x-kubernetes-map-type: atomic
                                      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
                                        x-kubernetes-map-type: atomic
                                      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
                                        x-kubernetes-map-type: atomic
                                      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
                                            type: string
                                          optional:
                                            description: Specify whether the Secret
                                              or its key must be defined
                                            type: boolean
                                        required:
                                        - key
                                        type: object
                                        x-kubernetes-map-type: atomic
                                    type: object
                                required:
                                - name
                                type: object
                              type: array
                              x-kubernetes-preserve-unknown-fields: true
                            restorePointInTime:
                              description: |-
                                Specifies the point in time to which the restore should be performed.
                                Supported time formats:

                                - RFC3339 format, e.g. "2023-11-25T18:52:53Z"
                                - A human-readable date-time format, e.g. "Jul 25,2023 18:52:53 UTC+0800"
                              type: string
                            sourceTargetName:
                              description: |-
                                Specifies the backup source target name to restore from.
                                This field is required when the referenced Backup has multiple source targets.
                                It is propagated to Restore.spec.backup.sourceTargetName.
                              type: string
                          required:
                          - name
                          type: object
                        instances:
                          description: |-
                            Modifies the desired replicas count for existing InstanceTemplate.
                            if the inst
                          items:
                            description: InstanceReplicasTemplate defines the template
                              for instance replicas.
                            properties:
                              name:
                                description: Specifies the name of the instance template.
                                type: string
                              replicaChanges:
                                description: Specifies the replica changes for the
                                  instance template.
                                format: int32
                                minimum: 0
                                type: integer
                            required:
                            - name
                            - replicaChanges
                            type: object
                          type: array
                          x-kubernetes-list-map-keys:
                          - name
                          x-kubernetes-list-type: map
                        newInstances:
                          description: |-
                            Defines the configuration for new instances added during scaling, including resource requirements, labels, annotations, etc.
                            New instances are created based on the provided instance templates.
                          items:
                            description: InstanceTemplate allows customization of
                              individual replica configurations in a Component.
                            properties:
                              annotations:
                                additionalProperties:
                                  type: string
                                description: |-
                                  Specifies a map of key-value pairs to be merged into the Pod's existing annotations.
                                  Existing keys will have their values overwritten, while new keys will be added to the annotations.
                                type: object
                              canary:
                                description: Indicate whether the instances belonging
                                  to this template are canary instances.
                                type: boolean
                              compDef:
                                description: Specifies the name of the referenced
                                  ComponentDefinition.
                                maxLength: 64
                                type: string
                              env:
                                description: |-
                                  Defines Env to override.
                                  Add new or override existing envs.
                                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
                                              type: string
                                            optional:
                                              description: Specify whether the ConfigMap
                                                or its key must be defined
                                              type: boolean
                                          required:
                                          - key
                                          type: object
                                          x-kubernetes-map-type: atomic
                                        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
                                          x-kubernetes-map-type: atomic
                                        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
                                          x-kubernetes-map-type: atomic
                                        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
                                              type: string
                                            optional:
                                              description: Specify whether the Secret
                                                or its key must be defined
                                              type: boolean
                                          required:
                                          - key
                                          type: object
                                          x-kubernetes-map-type: atomic
                                      type: object
                                  required:
                                  - name
                                  type: object
                                type: array
                              labels:
                                additionalProperties:
                                  type: string
                                description: |-
                                  Specifies a map of key-value pairs that will be merged into the Pod's existing labels.
                                  Values for existing keys will be overwritten, and new keys will be added.
                                type: object
                              name:
                                description: |-
                                  Name specifies the unique name of the instance Pod created using this InstanceTemplate.
                                  This name is constructed by concatenating the Component's name, the template's name, and the instance's ordinal
                                  using the pattern: $(cluster.name)-$(component.name)-$(template.name)-$(ordinal). Ordinals start from 0.
                                  The name can't be empty.
                                maxLength: 54
                                pattern: ^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$
                                type: string
                              ordinals:
                                description: |-
                                  Specifies the desired Ordinals of this InstanceTemplate.
                                  The Ordinals used to specify the ordinal of the instance (pod) names to be generated under this InstanceTemplate.
                                  If Ordinals are defined, their number must be equal to or more than the corresponding replicas.

                                  For example, if Ordinals is {ranges: [{start: 0, end: 1}], discrete: [7]},
                                  then the instance names generated under this InstanceTemplate would be
                                  $(cluster.name)-$(component.name)-$(template.name)-0、$(cluster.name)-$(component.name)-$(template.name)-1 and
                                  $(cluster.name)-$(component.name)-$(template.name)-7
                                properties:
                                  discrete:
                                    items:
                                      format: int32
                                      type: integer
                                    type: array
                                  ranges:
                                    items:
                                      description: |-
                                        Range represents a range with a start and an end value. Both start and end are included.
                                        It is used to define a continuous segment.
                                      properties:
                                        end:
                                          format: int32
                                          type: integer
                                        start:
                                          format: int32
                                          type: integer
                                      required:
                                      - end
                                      - start
                                      type: object
                                    type: array
                                type: object
                              replicas:
                                default: 1
                                description: |-
                                  Specifies the number of instances (Pods) to create from this InstanceTemplate.
                                  This field allows setting how many replicated instances of the Component,
                                  with the specific overrides in the InstanceTemplate, are created.
                                  The default value is 1. A value of 0 disables instance creation.
                                format: int32
                                minimum: 0
                                type: integer
                              resources:
                                description: |-
                                  Specifies an override for the resource requirements of the first container in the Pod.
                                  This field allows for customizing resource allocation (CPU, memory, etc.) for the container.
                                properties:
                                  claims:
                                    description: |-
                                      Claims lists the names of resources, defined in spec.resourceClaims,
                                      that are used by this container.

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

                                      This field is immutable. It can only be set for containers.
                                    items:
                                      description: ResourceClaim references one entry
                                        in PodSpec.ResourceClaims.
                                      properties:
                                        name:
                                          description: |-
                                            Name must match the name of one entry in pod.spec.resourceClaims of
                                            the Pod where this field is used. It makes that resource available
                                            inside a container.
                                          type: string
                                      required:
                                      - name
                                      type: object
                                    type: array
                                    x-kubernetes-list-map-keys:
                                    - name
                                    x-kubernetes-list-type: map
                                  limits:
                                    additionalProperties:
                                      anyOf:
                                      - type: integer
                                      - type: string
                                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                      x-kubernetes-int-or-string: true
                                    description: |-
                                      Limits describes the maximum amount of compute resources allowed.
                                      More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                    type: object
                                  requests:
                                    additionalProperties:
                                      anyOf:
                                      - type: integer
                                      - type: string
                                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                      x-kubernetes-int-or-string: true
                                    description: |-
                                      Requests describes the minimum amount of compute resources required.
                                      If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                                      otherwise to an implementation-defined value. Requests cannot exceed Limits.
                                      More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                    type: object
                                type: object
                              schedulingPolicy:
                                description: |-
                                  Specifies the scheduling policy for the instance.
                                  If defined, it will overwrite the scheduling policy defined in ClusterSpec and/or ClusterComponentSpec.
                                properties:
                                  affinity:
                                    description: Specifies a group of affinity scheduling
                                      rules of the Cluster, including NodeAffinity,
                                      PodAffinity, and PodAntiAffinity.
                                    properties:
                                      nodeAffinity:
                                        description: Describes node affinity scheduling
                                          rules for the pod.
                                        properties:
                                          preferredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              The scheduler will prefer to schedule pods to nodes that satisfy
                                              the affinity expressions specified by this field, but it may choose
                                              a node that violates one or more of the expressions. The node that is
                                              most preferred is the one with the greatest sum of weights, i.e.
                                              for each node that meets all of the scheduling requirements (resource
                                              request, requiredDuringScheduling affinity expressions, etc.),
                                              compute a sum by iterating through the elements of this field and adding
                                              "weight" to the sum if the node matches the corresponding matchExpressions; the
                                              node(s) with the highest sum are the most preferred.
                                            items:
                                              description: |-
                                                An empty preferred scheduling term matches all objects with implicit weight 0
                                                (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                                              properties:
                                                preference:
                                                  description: A node selector term,
                                                    associated with the corresponding
                                                    weight.
                                                  properties:
                                                    matchExpressions:
                                                      description: A list of node
                                                        selector requirements by node's
                                                        labels.
                                                      items:
                                                        description: |-
                                                          A node selector requirement is a selector that contains values, a key, and an operator
                                                          that relates the key and values.
                                                        properties:
                                                          key:
                                                            description: The label
                                                              key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              Represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              An array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. If the operator is Gt or Lt, the values
                                                              array must have a single element, which will be interpreted as an integer.
                                                              This array is replaced during a strategic merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        required:
                                                        - key
                                                        - operator
                                                        type: object
                                                      type: array
                                                    matchFields:
                                                      description: A list of node
                                                        selector requirements by node's
                                                        fields.
                                                      items:
                                                        description: |-
                                                          A node selector requirement is a selector that contains values, a key, and an operator
                                                          that relates the key and values.
                                                        properties:
                                                          key:
                                                            description: The label
                                                              key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              Represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              An array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. If the operator is Gt or Lt, the values
                                                              array must have a single element, which will be interpreted as an integer.
                                                              This array is replaced during a strategic merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        required:
                                                        - key
                                                        - operator
                                                        type: object
                                                      type: array
                                                  type: object
                                                  x-kubernetes-map-type: atomic
                                                weight:
                                                  description: Weight associated with
                                                    matching the corresponding nodeSelectorTerm,
                                                    in the range 1-100.
                                                  format: int32
                                                  type: integer
                                              required:
                                              - preference
                                              - weight
                                              type: object
                                            type: array
                                          requiredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              If the affinity requirements specified by this field are not met at
                                              scheduling time, the pod will not be scheduled onto the node.
                                              If the affinity requirements specified by this field cease to be met
                                              at some point during pod execution (e.g. due to an update), the system
                                              may or may not try to eventually evict the pod from its node.
                                            properties:
                                              nodeSelectorTerms:
                                                description: Required. A list of node
                                                  selector terms. The terms are ORed.
                                                items:
                                                  description: |-
                                                    A null or empty node selector term matches no objects. The requirements of
                                                    them are ANDed.
                                                    The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                                                  properties:
                                                    matchExpressions:
                                                      description: A list of node
                                                        selector requirements by node's
                                                        labels.
                                                      items:
                                                        description: |-
                                                          A node selector requirement is a selector that contains values, a key, and an operator
                                                          that relates the key and values.
                                                        properties:
                                                          key:
                                                            description: The label
                                                              key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              Represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              An array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. If the operator is Gt or Lt, the values
                                                              array must have a single element, which will be interpreted as an integer.
                                                              This array is replaced during a strategic merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        required:
                                                        - key
                                                        - operator
                                                        type: object
                                                      type: array
                                                    matchFields:
                                                      description: A list of node
                                                        selector requirements by node's
                                                        fields.
                                                      items:
                                                        description: |-
                                                          A node selector requirement is a selector that contains values, a key, and an operator
                                                          that relates the key and values.
                                                        properties:
                                                          key:
                                                            description: The label
                                                              key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              Represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              An array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. If the operator is Gt or Lt, the values
                                                              array must have a single element, which will be interpreted as an integer.
                                                              This array is replaced during a strategic merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        required:
                                                        - key
                                                        - operator
                                                        type: object
                                                      type: array
                                                  type: object
                                                  x-kubernetes-map-type: atomic
                                                type: array
                                            required:
                                            - nodeSelectorTerms
                                            type: object
                                            x-kubernetes-map-type: atomic
                                        type: object
                                      podAffinity:
                                        description: Describes pod affinity scheduling
                                          rules (e.g. co-locate this pod in the same
                                          node, zone, etc. as some other pod(s)).
                                        properties:
                                          preferredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              The scheduler will prefer to schedule pods to nodes that satisfy
                                              the affinity expressions specified by this field, but it may choose
                                              a node that violates one or more of the expressions. The node that is
                                              most preferred is the one with the greatest sum of weights, i.e.
                                              for each node that meets all of the scheduling requirements (resource
                                              request, requiredDuringScheduling affinity expressions, etc.),
                                              compute a sum by iterating through the elements of this field and adding
                                              "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                              node(s) with the highest sum are the most preferred.
                                            items:
                                              description: The weights of all of the
                                                matched WeightedPodAffinityTerm fields
                                                are added per-node to find the most
                                                preferred node(s)
                                              properties:
                                                podAffinityTerm:
                                                  description: Required. A pod affinity
                                                    term, associated with the corresponding
                                                    weight.
                                                  properties:
                                                    labelSelector:
                                                      description: |-
                                                        A label query over a set of resources, in this case pods.
                                                        If it's null, this PodAffinityTerm matches with no Pods.
                                                      properties:
                                                        matchExpressions:
                                                          description: matchExpressions
                                                            is a list of label selector
                                                            requirements. The requirements
                                                            are ANDed.
                                                          items:
                                                            description: |-
                                                              A label selector requirement is a selector that contains values, a key, and an operator that
                                                              relates the key and values.
                                                            properties:
                                                              key:
                                                                description: key is
                                                                  the label key that
                                                                  the selector applies
                                                                  to.
                                                                type: string
                                                              operator:
                                                                description: |-
                                                                  operator represents a key's relationship to a set of values.
                                                                  Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                type: string
                                                              values:
                                                                description: |-
                                                                  values is an array of string values. If the operator is In or NotIn,
                                                                  the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                  the values array must be empty. This array is replaced during a strategic
                                                                  merge patch.
                                                                items:
                                                                  type: string
                                                                type: array
                                                            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
                                                      x-kubernetes-map-type: atomic
                                                    matchLabelKeys:
                                                      description: |-
                                                        MatchLabelKeys is a set of pod label keys to select which pods will
                                                        be taken into consideration. The keys are used to lookup values from the
                                                        incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)`
                                                        to select the group of existing pods which pods will be taken into consideration
                                                        for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                        pod labels will be ignored. The default value is empty.
                                                        The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                                        Also, MatchLabelKeys cannot be set when LabelSelector isn't set.
                                                        This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                      items:
                                                        type: string
                                                      type: array
                                                      x-kubernetes-list-type: atomic
                                                    mismatchLabelKeys:
                                                      description: |-
                                                        MismatchLabelKeys is a set of pod label keys to select which pods will
                                                        be taken into consideration. The keys are used to lookup values from the
                                                        incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)`
                                                        to select the group of existing pods which pods will be taken into consideration
                                                        for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                        pod labels will be ignored. The default value is empty.
                                                        The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector.
                                                        Also, MismatchLabelKeys cannot be set when LabelSelector isn't set.
                                                        This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                      items:
                                                        type: string
                                                      type: array
                                                      x-kubernetes-list-type: atomic
                                                    namespaceSelector:
                                                      description: |-
                                                        A label query over the set of namespaces that the term applies to.
                                                        The term is applied to the union of the namespaces selected by this field
                                                        and the ones listed in the namespaces field.
                                                        null selector and null or empty namespaces list means "this pod's namespace".
                                                        An empty selector ({}) matches all namespaces.
                                                      properties:
                                                        matchExpressions:
                                                          description: matchExpressions
                                                            is a list of label selector
                                                            requirements. The requirements
                                                            are ANDed.
                                                          items:
                                                            description: |-
                                                              A label selector requirement is a selector that contains values, a key, and an operator that
                                                              relates the key and values.
                                                            properties:
                                                              key:
                                                                description: key is
                                                                  the label key that
                                                                  the selector applies
                                                                  to.
                                                                type: string
                                                              operator:
                                                                description: |-
                                                                  operator represents a key's relationship to a set of values.
                                                                  Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                type: string
                                                              values:
                                                                description: |-
                                                                  values is an array of string values. If the operator is In or NotIn,
                                                                  the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                  the values array must be empty. This array is replaced during a strategic
                                                                  merge patch.
                                                                items:
                                                                  type: string
                                                                type: array
                                                            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
                                                      x-kubernetes-map-type: atomic
                                                    namespaces:
                                                      description: |-
                                                        namespaces specifies a static list of namespace names that the term applies to.
                                                        The term is applied to the union of the namespaces listed in this field
                                                        and the ones selected by namespaceSelector.
                                                        null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                      items:
                                                        type: string
                                                      type: array
                                                    topologyKey:
                                                      description: |-
                                                        This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                        the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                        whose value of the label with key topologyKey matches that of any node on which any of the
                                                        selected pods is running.
                                                        Empty topologyKey is not allowed.
                                                      type: string
                                                  required:
                                                  - topologyKey
                                                  type: object
                                                weight:
                                                  description: |-
                                                    weight associated with matching the corresponding podAffinityTerm,
                                                    in the range 1-100.
                                                  format: int32
                                                  type: integer
                                              required:
                                              - podAffinityTerm
                                              - weight
                                              type: object
                                            type: array
                                          requiredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              If the affinity requirements specified by this field are not met at
                                              scheduling time, the pod will not be scheduled onto the node.
                                              If the affinity requirements specified by this field cease to be met
                                              at some point during pod execution (e.g. due to a pod label update), the
                                              system may or may not try to eventually evict the pod from its node.
                                              When there are multiple elements, the lists of nodes corresponding to each
                                              podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                            items:
                                              description: |-
                                                Defines a set of pods (namely those matching the labelSelector
                                                relative to the given namespace(s)) that this pod should be
                                                co-located (affinity) or not co-located (anti-affinity) with,
                                                where co-located is defined as running on a node whose value of
                                                the label with key <topologyKey> matches that of any node on which
                                                a pod of the set of pods is running
                                              properties:
                                                labelSelector:
                                                  description: |-
                                                    A label query over a set of resources, in this case pods.
                                                    If it's null, this PodAffinityTerm matches with no Pods.
                                                  properties:
                                                    matchExpressions:
                                                      description: matchExpressions
                                                        is a list of label selector
                                                        requirements. The requirements
                                                        are ANDed.
                                                      items:
                                                        description: |-
                                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                                          relates the key and values.
                                                        properties:
                                                          key:
                                                            description: key is the
                                                              label key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              operator represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              values is an array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. This array is replaced during a strategic
                                                              merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        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
                                                  x-kubernetes-map-type: atomic
                                                matchLabelKeys:
                                                  description: |-
                                                    MatchLabelKeys is a set of pod label keys to select which pods will
                                                    be taken into consideration. The keys are used to lookup values from the
                                                    incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)`
                                                    to select the group of existing pods which pods will be taken into consideration
                                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                    pod labels will be ignored. The default value is empty.
                                                    The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                                    Also, MatchLabelKeys cannot be set when LabelSelector isn't set.
                                                    This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                                mismatchLabelKeys:
                                                  description: |-
                                                    MismatchLabelKeys is a set of pod label keys to select which pods will
                                                    be taken into consideration. The keys are used to lookup values from the
                                                    incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)`
                                                    to select the group of existing pods which pods will be taken into consideration
                                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                    pod labels will be ignored. The default value is empty.
                                                    The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector.
                                                    Also, MismatchLabelKeys cannot be set when LabelSelector isn't set.
                                                    This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                                namespaceSelector:
                                                  description: |-
                                                    A label query over the set of namespaces that the term applies to.
                                                    The term is applied to the union of the namespaces selected by this field
                                                    and the ones listed in the namespaces field.
                                                    null selector and null or empty namespaces list means "this pod's namespace".
                                                    An empty selector ({}) matches all namespaces.
                                                  properties:
                                                    matchExpressions:
                                                      description: matchExpressions
                                                        is a list of label selector
                                                        requirements. The requirements
                                                        are ANDed.
                                                      items:
                                                        description: |-
                                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                                          relates the key and values.
                                                        properties:
                                                          key:
                                                            description: key is the
                                                              label key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              operator represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              values is an array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. This array is replaced during a strategic
                                                              merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        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
                                                  x-kubernetes-map-type: atomic
                                                namespaces:
                                                  description: |-
                                                    namespaces specifies a static list of namespace names that the term applies to.
                                                    The term is applied to the union of the namespaces listed in this field
                                                    and the ones selected by namespaceSelector.
                                                    null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                  items:
                                                    type: string
                                                  type: array
                                                topologyKey:
                                                  description: |-
                                                    This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                    the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                    whose value of the label with key topologyKey matches that of any node on which any of the
                                                    selected pods is running.
                                                    Empty topologyKey is not allowed.
                                                  type: string
                                              required:
                                              - topologyKey
                                              type: object
                                            type: array
                                        type: object
                                      podAntiAffinity:
                                        description: Describes pod anti-affinity scheduling
                                          rules (e.g. avoid putting this pod in the
                                          same node, zone, etc. as some other pod(s)).
                                        properties:
                                          preferredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              The scheduler will prefer to schedule pods to nodes that satisfy
                                              the anti-affinity expressions specified by this field, but it may choose
                                              a node that violates one or more of the expressions. The node that is
                                              most preferred is the one with the greatest sum of weights, i.e.
                                              for each node that meets all of the scheduling requirements (resource
                                              request, requiredDuringScheduling anti-affinity expressions, etc.),
                                              compute a sum by iterating through the elements of this field and adding
                                              "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                              node(s) with the highest sum are the most preferred.
                                            items:
                                              description: The weights of all of the
                                                matched WeightedPodAffinityTerm fields
                                                are added per-node to find the most
                                                preferred node(s)
                                              properties:
                                                podAffinityTerm:
                                                  description: Required. A pod affinity
                                                    term, associated with the corresponding
                                                    weight.
                                                  properties:
                                                    labelSelector:
                                                      description: |-
                                                        A label query over a set of resources, in this case pods.
                                                        If it's null, this PodAffinityTerm matches with no Pods.
                                                      properties:
                                                        matchExpressions:
                                                          description: matchExpressions
                                                            is a list of label selector
                                                            requirements. The requirements
                                                            are ANDed.
                                                          items:
                                                            description: |-
                                                              A label selector requirement is a selector that contains values, a key, and an operator that
                                                              relates the key and values.
                                                            properties:
                                                              key:
                                                                description: key is
                                                                  the label key that
                                                                  the selector applies
                                                                  to.
                                                                type: string
                                                              operator:
                                                                description: |-
                                                                  operator represents a key's relationship to a set of values.
                                                                  Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                type: string
                                                              values:
                                                                description: |-
                                                                  values is an array of string values. If the operator is In or NotIn,
                                                                  the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                  the values array must be empty. This array is replaced during a strategic
                                                                  merge patch.
                                                                items:
                                                                  type: string
                                                                type: array
                                                            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
                                                      x-kubernetes-map-type: atomic
                                                    matchLabelKeys:
                                                      description: |-
                                                        MatchLabelKeys is a set of pod label keys to select which pods will
                                                        be taken into consideration. The keys are used to lookup values from the
                                                        incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)`
                                                        to select the group of existing pods which pods will be taken into consideration
                                                        for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                        pod labels will be ignored. The default value is empty.
                                                        The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                                        Also, MatchLabelKeys cannot be set when LabelSelector isn't set.
                                                        This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                      items:
                                                        type: string
                                                      type: array
                                                      x-kubernetes-list-type: atomic
                                                    mismatchLabelKeys:
                                                      description: |-
                                                        MismatchLabelKeys is a set of pod label keys to select which pods will
                                                        be taken into consideration. The keys are used to lookup values from the
                                                        incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)`
                                                        to select the group of existing pods which pods will be taken into consideration
                                                        for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                        pod labels will be ignored. The default value is empty.
                                                        The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector.
                                                        Also, MismatchLabelKeys cannot be set when LabelSelector isn't set.
                                                        This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                      items:
                                                        type: string
                                                      type: array
                                                      x-kubernetes-list-type: atomic
                                                    namespaceSelector:
                                                      description: |-
                                                        A label query over the set of namespaces that the term applies to.
                                                        The term is applied to the union of the namespaces selected by this field
                                                        and the ones listed in the namespaces field.
                                                        null selector and null or empty namespaces list means "this pod's namespace".
                                                        An empty selector ({}) matches all namespaces.
                                                      properties:
                                                        matchExpressions:
                                                          description: matchExpressions
                                                            is a list of label selector
                                                            requirements. The requirements
                                                            are ANDed.
                                                          items:
                                                            description: |-
                                                              A label selector requirement is a selector that contains values, a key, and an operator that
                                                              relates the key and values.
                                                            properties:
                                                              key:
                                                                description: key is
                                                                  the label key that
                                                                  the selector applies
                                                                  to.
                                                                type: string
                                                              operator:
                                                                description: |-
                                                                  operator represents a key's relationship to a set of values.
                                                                  Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                type: string
                                                              values:
                                                                description: |-
                                                                  values is an array of string values. If the operator is In or NotIn,
                                                                  the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                  the values array must be empty. This array is replaced during a strategic
                                                                  merge patch.
                                                                items:
                                                                  type: string
                                                                type: array
                                                            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
                                                      x-kubernetes-map-type: atomic
                                                    namespaces:
                                                      description: |-
                                                        namespaces specifies a static list of namespace names that the term applies to.
                                                        The term is applied to the union of the namespaces listed in this field
                                                        and the ones selected by namespaceSelector.
                                                        null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                      items:
                                                        type: string
                                                      type: array
                                                    topologyKey:
                                                      description: |-
                                                        This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                        the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                        whose value of the label with key topologyKey matches that of any node on which any of the
                                                        selected pods is running.
                                                        Empty topologyKey is not allowed.
                                                      type: string
                                                  required:
                                                  - topologyKey
                                                  type: object
                                                weight:
                                                  description: |-
                                                    weight associated with matching the corresponding podAffinityTerm,
                                                    in the range 1-100.
                                                  format: int32
                                                  type: integer
                                              required:
                                              - podAffinityTerm
                                              - weight
                                              type: object
                                            type: array
                                          requiredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              If the anti-affinity requirements specified by this field are not met at
                                              scheduling time, the pod will not be scheduled onto the node.
                                              If the anti-affinity requirements specified by this field cease to be met
                                              at some point during pod execution (e.g. due to a pod label update), the
                                              system may or may not try to eventually evict the pod from its node.
                                              When there are multiple elements, the lists of nodes corresponding to each
                                              podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                            items:
                                              description: |-
                                                Defines a set of pods (namely those matching the labelSelector
                                                relative to the given namespace(s)) that this pod should be
                                                co-located (affinity) or not co-located (anti-affinity) with,
                                                where co-located is defined as running on a node whose value of
                                                the label with key <topologyKey> matches that of any node on which
                                                a pod of the set of pods is running
                                              properties:
                                                labelSelector:
                                                  description: |-
                                                    A label query over a set of resources, in this case pods.
                                                    If it's null, this PodAffinityTerm matches with no Pods.
                                                  properties:
                                                    matchExpressions:
                                                      description: matchExpressions
                                                        is a list of label selector
                                                        requirements. The requirements
                                                        are ANDed.
                                                      items:
                                                        description: |-
                                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                                          relates the key and values.
                                                        properties:
                                                          key:
                                                            description: key is the
                                                              label key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              operator represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              values is an array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. This array is replaced during a strategic
                                                              merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        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
                                                  x-kubernetes-map-type: atomic
                                                matchLabelKeys:
                                                  description: |-
                                                    MatchLabelKeys is a set of pod label keys to select which pods will
                                                    be taken into consideration. The keys are used to lookup values from the
                                                    incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)`
                                                    to select the group of existing pods which pods will be taken into consideration
                                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                    pod labels will be ignored. The default value is empty.
                                                    The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                                    Also, MatchLabelKeys cannot be set when LabelSelector isn't set.
                                                    This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                                mismatchLabelKeys:
                                                  description: |-
                                                    MismatchLabelKeys is a set of pod label keys to select which pods will
                                                    be taken into consideration. The keys are used to lookup values from the
                                                    incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)`
                                                    to select the group of existing pods which pods will be taken into consideration
                                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                    pod labels will be ignored. The default value is empty.
                                                    The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector.
                                                    Also, MismatchLabelKeys cannot be set when LabelSelector isn't set.
                                                    This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                                namespaceSelector:
                                                  description: |-
                                                    A label query over the set of namespaces that the term applies to.
                                                    The term is applied to the union of the namespaces selected by this field
                                                    and the ones listed in the namespaces field.
                                                    null selector and null or empty namespaces list means "this pod's namespace".
                                                    An empty selector ({}) matches all namespaces.
                                                  properties:
                                                    matchExpressions:
                                                      description: matchExpressions
                                                        is a list of label selector
                                                        requirements. The requirements
                                                        are ANDed.
                                                      items:
                                                        description: |-
                                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                                          relates the key and values.
                                                        properties:
                                                          key:
                                                            description: key is the
                                                              label key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              operator represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              values is an array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. This array is replaced during a strategic
                                                              merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        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
                                                  x-kubernetes-map-type: atomic
                                                namespaces:
                                                  description: |-
                                                    namespaces specifies a static list of namespace names that the term applies to.
                                                    The term is applied to the union of the namespaces listed in this field
                                                    and the ones selected by namespaceSelector.
                                                    null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                  items:
                                                    type: string
                                                  type: array
                                                topologyKey:
                                                  description: |-
                                                    This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                    the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                    whose value of the label with key topologyKey matches that of any node on which any of the
                                                    selected pods is running.
                                                    Empty topologyKey is not allowed.
                                                  type: string
                                              required:
                                              - topologyKey
                                              type: object
                                            type: array
                                        type: object
                                    type: object
                                  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
                                  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
                                  tolerations:
                                    description: |-
                                      Allows Pods to be scheduled onto nodes with matching taints.
                                      Each toleration in the array allows the Pod to tolerate node taints based on
                                      specified `key`, `value`, `effect`, and `operator`.

                                      - The `key`, `value`, and `effect` identify the taint that the toleration matches.
                                      - The `operator` determines how the toleration matches the taint.

                                      Pods with matching tolerations are allowed to be scheduled on tainted nodes, typically reserved for specific purposes.
                                    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
                                          x-kubernetes-map-type: atomic
                                        matchLabelKeys:
                                          description: |-
                                            MatchLabelKeys is a set of pod label keys to select the pods over which
                                            spreading will be calculated. The keys are used to lookup values from the
                                            incoming pod labels, those key-value labels are ANDed with labelSelector
                                            to select the group of existing pods over which spreading will be calculated
                                            for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                            MatchLabelKeys cannot be set when LabelSelector isn't set.
                                            Keys that don't exist in the incoming pod labels will
                                            be ignored. A null or empty list means only match against labelSelector.

                                            This is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).
                                          items:
                                            type: string
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        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.
                                            The global minimum is the minimum number of matching pods in an eligible domain
                                            or zero if the number of eligible domains is less than MinDomains.
                                            For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same
                                            labelSelector spread as 2/2/1:
                                            In this case, the global minimum is 1.
                                            | zone1 | zone2 | zone3 |
                                            |  P P  |  P P  |   P   |
                                            - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2;
                                            scheduling it onto zone1(zone2) would make the ActualSkew(3-1) 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
                                        minDomains:
                                          description: |-
                                            MinDomains indicates a minimum number of eligible domains.
                                            When the number of eligible domains with matching topology keys is less than minDomains,
                                            Pod Topology Spread treats "global minimum" as 0, and then the calculation of Skew is performed.
                                            And when the number of eligible domains with matching topology keys equals or greater than minDomains,
                                            this value has no effect on scheduling.
                                            As a result, when the number of eligible domains is less than minDomains,
                                            scheduler won't schedule more than maxSkew Pods to those domains.
                                            If value is nil, the constraint behaves as if MinDomains is equal to 1.
                                            Valid values are integers greater than 0.
                                            When value is not nil, WhenUnsatisfiable must be DoNotSchedule.

                                            For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same
                                            labelSelector spread as 2/2/2:
                                            | zone1 | zone2 | zone3 |
                                            |  P P  |  P P  |  P P  |
                                            The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0.
                                            In this situation, new pod with the same labelSelector cannot be scheduled,
                                            because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones,
                                            it will violate MaxSkew.

                                            This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).
                                          format: int32
                                          type: integer
                                        nodeAffinityPolicy:
                                          description: |-
                                            NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector
                                            when calculating pod topology spread skew. Options are:
                                            - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations.
                                            - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.

                                            If this value is nil, the behavior is equivalent to the Honor policy.
                                            This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
                                          type: string
                                        nodeTaintsPolicy:
                                          description: |-
                                            NodeTaintsPolicy indicates how we will treat node taints when calculating
                                            pod topology spread skew. Options are:
                                            - Honor: nodes without taints, along with tainted nodes for which the incoming pod
                                            has a toleration, are included.
                                            - Ignore: node taints are ignored. All nodes are included.

                                            If this value is nil, the behavior is equivalent to the Ignore policy.
                                            This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
                                          type: string
                                        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.
                                            We define a domain as a particular instance of a topology.
                                            Also, we define an eligible domain as a domain whose nodes meet the requirements of
                                            nodeAffinityPolicy and nodeTaintsPolicy.
                                            e.g. If TopologyKey is "kubernetes.io/hostname", each Node is a domain of that topology.
                                            And, if TopologyKey is "topology.kubernetes.io/zone", each zone is a domain of that topology.
                                            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
                                type: object
                              serviceVersion:
                                description: |-
                                  ServiceVersion specifies the version of the Service expected to be provisioned by this InstanceTemplate.
                                  The version should follow the syntax and semantics of the "Semantic Versioning" specification (http://semver.org/).
                                maxLength: 32
                                type: string
                              volumeClaimTemplates:
                                description: Specifies an override for the storage
                                  requirements of the instances.
                                items:
                                  properties:
                                    annotations:
                                      additionalProperties:
                                        type: string
                                      description: Specifies the annotations for the
                                        PVC of the volume.
                                      type: object
                                    labels:
                                      additionalProperties:
                                        type: string
                                      description: Specifies the labels for the PVC
                                        of the volume.
                                      type: object
                                    name:
                                      description: |-
                                        Refers to the name of a volumeMount defined in either:

                                        - `componentDefinition.spec.runtime.containers[*].volumeMounts`

                                        The value of `name` must match the `name` field of a volumeMount specified in the corresponding `volumeMounts` array.
                                      type: string
                                    persistentVolumeClaimName:
                                      description: |-
                                        Specifies the prefix of the PVC name for the volume.

                                        For each replica, the final name of the PVC will be in format: <persistentVolumeClaimName>-<ordinal>
                                      type: string
                                    spec:
                                      description: |-
                                        Defines the desired characteristics of a PersistentVolumeClaim that will be created for the volume
                                        with the mount name specified in the `name` field.
                                      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
                                        dataSource:
                                          description: |-
                                            dataSource field can be used to specify either:
                                            * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)
                                            * An existing PVC (PersistentVolumeClaim)
                                            If the provisioner or an external controller can support the specified data source,
                                            it will create a new volume based on the contents of the specified data source.
                                            When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef,
                                            and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified.
                                            If the namespace is specified, then dataSourceRef will not be copied to dataSource.
                                          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
                                          x-kubernetes-map-type: atomic
                                        dataSourceRef:
                                          description: |-
                                            dataSourceRef specifies the object from which to populate the volume with data, if a non-empty
                                            volume is desired. This may be any 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, when namespace isn't specified in dataSourceRef,
                                            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.
                                            When namespace is specified in dataSourceRef,
                                            dataSource isn't set to the same value and must be empty.
                                            There are three 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.
                                            * While dataSource only allows local objects, dataSourceRef allows objects
                                              in any namespaces.
                                            (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.
                                            (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource 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
                                            namespace:
                                              description: |-
                                                Namespace is the namespace of resource being referenced
                                                Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details.
                                                (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.
                                              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. Requests cannot exceed Limits.
                                                More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                              type: object
                                          type: object
                                        selector:
                                          description: selector is 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
                                          x-kubernetes-map-type: atomic
                                        storageClassName:
                                          description: |-
                                            storageClassName is the name of the StorageClass required by the claim.
                                            More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1
                                          type: string
                                        volumeAttributesClassName:
                                          description: |-
                                            volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim.
                                            If specified, the CSI driver will create or update the volume with the attributes defined
                                            in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName,
                                            it can be changed after the claim is created. An empty string value means that no VolumeAttributesClass
                                            will be applied to the claim but it's not allowed to reset this field to empty string once it is set.
                                            If unspecified and the PersistentVolumeClaim is unbound, the default VolumeAttributesClass
                                            will be set by the persistentvolume controller if it exists.
                                            If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be
                                            set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource
                                            exists.
                                            More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#volumeattributesclass
                                            (Alpha) Using this field requires the VolumeAttributesClass feature gate to be enabled.
                                          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:
                                  - name
                                  type: object
                                type: array
                            required:
                            - name
                            type: object
                          type: array
                          x-kubernetes-list-map-keys:
                          - name
                          x-kubernetes-list-type: map
                        offlineInstancesToOnline:
                          description: Specifies the instances in the offline list
                            to bring back online.
                          items:
                            type: string
                          type: array
                        replicaChanges:
                          description: Specifies the replica changes for the component.
                          format: int32
                          minimum: 0
                          type: integer
                      type: object
                    shards:
                      description: |-
                        Specifies the desired number of shards for the component.
                        This parameter is mutually exclusive with other parameters.
                      format: int32
                      type: integer
                  required:
                  - componentName
                  type: object
                  x-kubernetes-validations:
                  - message: shards field cannot be used together with scaleOut or
                      scaleIn
                    rule: 'has(self.shards) ? (!has(self.scaleOut) && !has(self.scaleIn))
                      : true'
                type: array
                x-kubernetes-list-map-keys:
                - componentName
                x-kubernetes-list-type: map
                x-kubernetes-validations:
                - message: forbidden to update spec.horizontalScaling
                  rule: self == oldSelf
              preConditionDeadlineSeconds:
                default: 0
                description: |-
                  Specifies the maximum time in seconds that the OpsRequest will wait for its pre-conditions to be met
                  before it aborts the operation.
                  If set to 0 (default), pre-conditions must be satisfied immediately for the OpsRequest to proceed.
                format: int32
                type: integer
              rebuildFrom:
                description: |-
                  Specifies the parameters to rebuild some instances.
                  Rebuilding an instance involves restoring its data from a backup or another database replica.
                  The instances being rebuilt usually serve as standby in the cluster.
                  Hence, rebuilding instances is often also referred to as "standby reconstruction".
                items:
                  properties:
                    backupName:
                      description: |-
                        Indicates the name of the Backup custom resource from which to recover the instance.
                        Defaults to an empty PersistentVolume if unspecified.

                        Note:
                        - Only full physical backups are supported for multi-replica Components (e.g., 'xtrabackup' for MySQL).
                        - Logical backups (e.g., 'mysqldump' for MySQL) are unsupported in the current version.
                      type: string
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec
                      type: string
                    inPlace:
                      description: |-
                        When it is set to true, the instance will be rebuilt in-place.
                        If false, a new pod will be created. Once the new pod is ready to serve,
                        the instance that require rebuilding will be taken offline.
                      type: boolean
                    instances:
                      description: Specifies the instances (Pods) that need to be
                        rebuilt, typically operating as standbys.
                      items:
                        properties:
                          name:
                            description: Pod name of the instance.
                            type: string
                          targetNodeName:
                            description: |-
                              The instance will rebuild on the specified node.
                              If not set, it will rebuild on a random node.
                            type: string
                        required:
                        - name
                        type: object
                      minItems: 1
                      type: array
                    restoreEnv:
                      description: |-
                        Defines container environment variables for the restore process.
                        merged with the ones specified in the Backup and ActionSet resources.

                        Merge priority: Restore env > Backup env > ActionSet env.

                        Purpose: Some databases require different configurations when being restored as a standby
                        compared to being restored as a primary.
                        For example, when restoring MySQL as a replica, you need to set `skip_slave_start="ON"` for 5.7
                        or `skip_replica_start="ON"` for 8.0.
                        Allowing environment variables to be passed in makes it more convenient to control these behavioral differences
                        during the restore process.
                      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
                                    type: string
                                  optional:
                                    description: Specify whether the ConfigMap or
                                      its key must be defined
                                    type: boolean
                                required:
                                - key
                                type: object
                                x-kubernetes-map-type: atomic
                              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
                                x-kubernetes-map-type: atomic
                              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
                                x-kubernetes-map-type: atomic
                              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
                                    type: string
                                  optional:
                                    description: Specify whether the Secret or its
                                      key must be defined
                                    type: boolean
                                required:
                                - key
                                type: object
                                x-kubernetes-map-type: atomic
                            type: object
                        required:
                        - name
                        type: object
                      type: array
                      x-kubernetes-preserve-unknown-fields: true
                    sourceBackupTargetName:
                      description: When multiple source targets exist of the backup,
                        you must specify the source target to restore.
                      type: string
                  required:
                  - componentName
                  - inPlace
                  - instances
                  type: object
                type: array
                x-kubernetes-list-map-keys:
                - componentName
                x-kubernetes-list-type: map
                x-kubernetes-validations:
                - message: forbidden to update spec.rebuildFrom
                  rule: self == oldSelf
              reconfigures:
                description: Lists Reconfigure objects, each specifying a Component
                  and its configuration updates.
                items:
                  description: Reconfigure defines the parameters for updating a Component's
                    configuration.
                  properties:
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec
                      type: string
                    parameters:
                      description: |-
                        Specifies a list of key-value pairs representing parameters and their corresponding values
                        within a single configuration file.
                        This field is used to override or set the values of parameters without modifying the entire configuration file.
                      items:
                        properties:
                          key:
                            description: Represents the name of the parameter that
                              is to be updated.
                            type: string
                          value:
                            description: |-
                              Represents the parameter values that are to be updated.
                              If set to nil, the parameter defined by the Key field will be removed from the configuration file.
                            type: string
                        required:
                        - key
                        type: object
                      type: array
                  required:
                  - componentName
                  type: object
                type: array
                x-kubernetes-list-map-keys:
                - componentName
                x-kubernetes-list-type: map
                x-kubernetes-validations:
                - message: forbidden to update spec.reconfigure
                  rule: self == oldSelf
              restart:
                description: Lists Components to be restarted.
                items:
                  description: ComponentOps specifies the Component to be operated
                    on.
                  properties:
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec
                      type: string
                  required:
                  - componentName
                  type: object
                maxItems: 1024
                type: array
                x-kubernetes-list-map-keys:
                - componentName
                x-kubernetes-list-type: map
                x-kubernetes-validations:
                - message: forbidden to update spec.restart
                  rule: self == oldSelf
              restore:
                description: |-
                  Specifies the parameters to restore a Cluster.
                  Note that this restore operation will roll back cluster services.
                properties:
                  backupName:
                    description: Specifies the name of the Backup custom resource.
                    type: string
                  backupNamespace:
                    description: Specifies the namespace of the backup custom resource.
                      If not specified, the namespace of the opsRequest will be used.
                    type: string
                  deferPostReadyUntilClusterRunning:
                    description: |-
                      Controls the timing of PostReady actions during the recovery process.

                      If false (default), PostReady actions execute when the Component reaches the "Running" state.
                      If true, PostReady actions are delayed until the entire Cluster is "Running,"
                      ensuring the cluster's overall stability before proceeding.

                      This setting is useful for coordinating PostReady operations across the Cluster for optimal cluster conditions.
                    type: boolean
                  env:
                    description: Specifies a list of environment variables to be set
                      in the 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
                                  type: string
                                optional:
                                  description: Specify whether the ConfigMap or its
                                    key must be defined
                                  type: boolean
                              required:
                              - key
                              type: object
                              x-kubernetes-map-type: atomic
                            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
                              x-kubernetes-map-type: atomic
                            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
                              x-kubernetes-map-type: atomic
                            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
                                  type: string
                                optional:
                                  description: Specify whether the Secret or its key
                                    must be defined
                                  type: boolean
                              required:
                              - key
                              type: object
                              x-kubernetes-map-type: atomic
                          type: object
                      required:
                      - name
                      type: object
                    type: array
                    x-kubernetes-preserve-unknown-fields: true
                  parameters:
                    description: |-
                      Specifies a list of name-value pairs representing parameters and their corresponding values.
                      Parameters match the schema specified in the `actionset.spec.parametersSchema`
                    items:
                      properties:
                        name:
                          description: Represents the name of the parameter.
                          type: string
                        value:
                          description: Represents the parameter values.
                          type: string
                      required:
                      - name
                      - value
                      type: object
                    maxItems: 128
                    type: array
                    x-kubernetes-list-map-keys:
                    - name
                    x-kubernetes-list-type: map
                    x-kubernetes-validations:
                    - message: forbidden to update parameters
                      rule: self == oldSelf
                  restorePointInTime:
                    description: |-
                      Specifies the point in time to which the restore should be performed.
                      Supported time formats:

                      - RFC3339 format, e.g. "2023-11-25T18:52:53Z"
                      - A human-readable date-time format, e.g. "Jul 25,2023 18:52:53 UTC+0800"
                    type: string
                  volumeRestorePolicy:
                    default: Parallel
                    description: |-
                      Specifies the policy for restoring volume claims of a Component's Pods.
                      It determines whether the volume claims should be restored sequentially (one by one) or in parallel (all at once).
                      Support values:

                      - "Serial"
                      - "Parallel"
                    enum:
                    - Serial
                    - Parallel
                    type: string
                required:
                - backupName
                type: object
                x-kubernetes-validations:
                - message: forbidden to update restore.parameters
                  rule: has(oldSelf.parameters) == has(self.parameters)
              start:
                description: Lists Components to be started. If empty, all components
                  will be started.
                items:
                  description: ComponentOps specifies the Component to be operated
                    on.
                  properties:
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec
                      type: string
                  required:
                  - componentName
                  type: object
                maxItems: 1024
                type: array
                x-kubernetes-list-map-keys:
                - componentName
                x-kubernetes-list-type: map
                x-kubernetes-validations:
                - message: forbidden to update spec.start
                  rule: self == oldSelf
              stop:
                description: Lists Components to be stopped. If empty, all components
                  will be stopped.
                items:
                  description: ComponentOps specifies the Component to be operated
                    on.
                  properties:
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec
                      type: string
                  required:
                  - componentName
                  type: object
                maxItems: 1024
                type: array
                x-kubernetes-list-map-keys:
                - componentName
                x-kubernetes-list-type: map
                x-kubernetes-validations:
                - message: forbidden to update spec.stop
                  rule: self == oldSelf
              switchover:
                description: Lists Switchover objects, each specifying a Component
                  to perform the switchover operation.
                items:
                  properties:
                    candidateName:
                      description: |-
                        If CandidateName is specified, the role will be transferred to this instance.
                        The name must match one of the pods in the component.
                        Refer to ComponentDefinition's Swtichover lifecycle action for more details.
                      type: string
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec.
                      type: string
                    componentObjectName:
                      description: Specifies the name of the Component object.
                      type: string
                    instanceName:
                      description: |-
                        Specifies the instance whose role will be transferred. A typical usage is to transfer the leader role
                        in a consensus system.
                      type: string
                  required:
                  - instanceName
                  type: object
                  x-kubernetes-validations:
                  - message: need to specified only componentName or componentObjectName
                    rule: (has(self.componentName) && !has(self.componentObjectName))
                      || (!has(self.componentName) && has(self.componentObjectName))
                type: array
                x-kubernetes-validations:
                - message: forbidden to update spec.switchover
                  rule: self == oldSelf
              timeoutSeconds:
                description: |-
                  Specifies the maximum duration (in seconds) that an opsRequest is allowed to run.
                  If the opsRequest runs longer than this duration, its phase will be marked as Aborted.
                  If this value is not set or set to 0, the timeout will be ignored and the opsRequest will run indefinitely.
                format: int32
                type: integer
              ttlSecondsAfterSucceed:
                description: |-
                  Specifies the duration in seconds that an OpsRequest will remain in the system after successfully completing
                  (when `opsRequest.status.phase` is "Succeed") before automatic deletion.
                format: int32
                type: integer
              ttlSecondsAfterUnsuccessfulCompletion:
                description: |-
                  Specifies the duration in seconds that an OpsRequest will remain in the system after completion
                  for any phase other than "Succeed" (e.g., "Failed", "Cancelled", "Aborted") before automatic deletion.
                format: int32
                type: integer
              type:
                description: |-
                  Specifies the type of this operation. Supported types include "Start", "Stop", "Restart", "Switchover",
                  "VerticalScaling", "HorizontalScaling", "VolumeExpansion", "Reconfiguring", "Upgrade", "Backup", "Restore",
                  "Expose", "RebuildInstance", "Custom".

                  Note: This field is immutable once set.
                enum:
                - Upgrade
                - VerticalScaling
                - VolumeExpansion
                - HorizontalScaling
                - Restart
                - Reconfiguring
                - Start
                - Stop
                - Expose
                - Switchover
                - Backup
                - Restore
                - RebuildInstance
                - Custom
                type: string
                x-kubernetes-validations:
                - message: forbidden to update spec.type
                  rule: self == oldSelf
              upgrade:
                description: |-
                  Specifies the desired new version of the Cluster.

                  Note: This field is immutable once set.
                properties:
                  components:
                    description: |-
                      Lists components to be upgrade based on desired ComponentDefinition and ServiceVersion.
                      From the perspective of cluster API, the reasonable combinations should be:
                      1. (comp-def, service-ver) - upgrade to the specified service version and component definition, the user takes the responsibility to ensure that they are compatible.
                      2. ("", service-ver) - upgrade to the specified service version, let the operator choose the latest compatible component definition.
                      3. (comp-def, "") - upgrade to the specified component definition, let the operator choose the latest compatible service version.
                      4. ("", "") - upgrade to the latest service version and component definition, the operator will ensure the compatibility between the selected versions.
                    items:
                      properties:
                        componentDefinitionName:
                          description: Specifies the name of the ComponentDefinition,
                            only exact matches are supported.
                          maxLength: 64
                          type: string
                        componentName:
                          description: Specifies the name of the Component as defined
                            in the cluster.spec
                          type: string
                        serviceVersion:
                          description: |-
                            Specifies the version of the Service expected to be provisioned by this Component.
                            Referring to the ServiceVersion defined by the ComponentDefinition and ComponentVersion.
                            And ServiceVersion in ClusterComponentSpec is optional, when no version is specified,
                            use the latest available version in ComponentVersion.
                          maxLength: 32
                          type: string
                      required:
                      - componentName
                      type: object
                      x-kubernetes-validations:
                      - message: at least one componentDefinitionName or serviceVersion
                        rule: has(self.componentDefinitionName) || has(self.serviceVersion)
                    maxItems: 1024
                    type: array
                    x-kubernetes-list-map-keys:
                    - componentName
                    x-kubernetes-list-type: map
                type: object
                x-kubernetes-validations:
                - message: forbidden to update spec.upgrade
                  rule: self == oldSelf
              verticalScaling:
                description: Lists VerticalScaling objects, each specifying a component
                  and its desired compute resources for vertical scaling.
                items:
                  description: |-
                    VerticalScaling refers to the process of adjusting compute resources (e.g., CPU, memory) allocated to a Component.
                    It defines the parameters required for the operation.
                  properties:
                    claims:
                      description: |-
                        Claims lists the names of resources, defined in spec.resourceClaims,
                        that are used by this container.

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

                        This field is immutable. It can only be set for containers.
                      items:
                        description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                        properties:
                          name:
                            description: |-
                              Name must match the name of one entry in pod.spec.resourceClaims of
                              the Pod where this field is used. It makes that resource available
                              inside a container.
                            type: string
                        required:
                        - name
                        type: object
                      type: array
                      x-kubernetes-list-map-keys:
                      - name
                      x-kubernetes-list-type: map
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec
                      type: string
                    instances:
                      description: Specifies the desired compute resources of the
                        instance template that need to vertical scale.
                      items:
                        properties:
                          claims:
                            description: |-
                              Claims lists the names of resources, defined in spec.resourceClaims,
                              that are used by this container.

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

                              This field is immutable. It can only be set for containers.
                            items:
                              description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                              properties:
                                name:
                                  description: |-
                                    Name must match the name of one entry in pod.spec.resourceClaims of
                                    the Pod where this field is used. It makes that resource available
                                    inside a container.
                                  type: string
                              required:
                              - name
                              type: object
                            type: array
                            x-kubernetes-list-map-keys:
                            - name
                            x-kubernetes-list-type: map
                          limits:
                            additionalProperties:
                              anyOf:
                              - type: integer
                              - type: string
                              pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                              x-kubernetes-int-or-string: true
                            description: |-
                              Limits describes the maximum amount of compute resources allowed.
                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                            type: object
                          name:
                            description: Refer to the instance template name of the
                              component or sharding.
                            type: string
                          requests:
                            additionalProperties:
                              anyOf:
                              - type: integer
                              - type: string
                              pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                              x-kubernetes-int-or-string: true
                            description: |-
                              Requests describes the minimum amount of compute resources required.
                              If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                              otherwise to an implementation-defined value. Requests cannot exceed Limits.
                              More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                            type: object
                        required:
                        - name
                        type: object
                        x-kubernetes-preserve-unknown-fields: true
                      type: array
                      x-kubernetes-list-map-keys:
                      - name
                      x-kubernetes-list-type: map
                    limits:
                      additionalProperties:
                        anyOf:
                        - type: integer
                        - type: string
                        pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                        x-kubernetes-int-or-string: true
                      description: |-
                        Limits describes the maximum amount of compute resources allowed.
                        More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                      type: object
                    requests:
                      additionalProperties:
                        anyOf:
                        - type: integer
                        - type: string
                        pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                        x-kubernetes-int-or-string: true
                      description: |-
                        Requests describes the minimum amount of compute resources required.
                        If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                        otherwise to an implementation-defined value. Requests cannot exceed Limits.
                        More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                      type: object
                  required:
                  - componentName
                  type: object
                  x-kubernetes-preserve-unknown-fields: true
                maxItems: 1024
                type: array
                x-kubernetes-list-map-keys:
                - componentName
                x-kubernetes-list-type: map
              volumeExpansion:
                description: |-
                  Lists VolumeExpansion objects, each specifying a component and its corresponding volumeClaimTemplates
                  that requires storage expansion.
                items:
                  description: VolumeExpansion encapsulates the parameters required
                    for a volume expansion operation.
                  properties:
                    componentName:
                      description: Specifies the name of the Component as defined
                        in the cluster.spec
                      type: string
                    volumeClaimTemplates:
                      description: |-
                        Specifies a list of OpsRequestVolumeClaimTemplate objects, defining the volumeClaimTemplates
                        that are used to expand the storage and the desired storage size for each one.
                      items:
                        properties:
                          name:
                            description: |-
                              Specify the name of the volumeClaimTemplate in the Component.
                              The specified name must match one of the volumeClaimTemplates defined
                              in the `clusterComponentSpec.volumeClaimTemplates` field.
                            type: string
                          storage:
                            anyOf:
                            - type: integer
                            - type: string
                            description: Specifies the desired storage size for the
                              volume.
                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                            x-kubernetes-int-or-string: true
                        required:
                        - name
                        - storage
                        type: object
                      type: array
                      x-kubernetes-list-map-keys:
                      - name
                      x-kubernetes-list-type: map
                  required:
                  - componentName
                  - volumeClaimTemplates
                  type: object
                type: array
                x-kubernetes-list-map-keys:
                - componentName
                x-kubernetes-list-type: map
            required:
            - type
            type: object
          status:
            description: OpsRequestStatus represents the observed state of an OpsRequest.
            properties:
              cancelTimestamp:
                description: Records the time when the OpsRequest was cancelled.
                format: date-time
                type: string
              clusterGeneration:
                description: Records the cluster generation after the OpsRequest action
                  has been handled.
                format: int64
                type: integer
              completionTimestamp:
                description: Records the time when the OpsRequest was completed.
                format: date-time
                type: string
              components:
                additionalProperties:
                  properties:
                    lastFailedTime:
                      description: Records the timestamp when the Component last transitioned
                        to a "Failed" phase.
                      format: date-time
                      type: string
                    message:
                      description: Provides a human-readable message indicating details
                        about this operation.
                      maxLength: 32768
                      type: string
                    phase:
                      description: Records the current phase of the Component, mirroring
                        `cluster.status.components[componentName].phase`.
                      enum:
                      - Creating
                      - Deleting
                      - Updating
                      - Stopping
                      - Starting
                      - Running
                      - Stopped
                      - Failed
                      type: string
                    preCheck:
                      description: Records the result of the preConditions check of
                        the opsRequest, which determines subsequent steps.
                      properties:
                        message:
                          description: Provides explanations related to the preCheck
                            result in a human-readable format.
                          type: string
                        pass:
                          description: Indicates whether the preCheck operation passed
                            or failed.
                          type: boolean
                      required:
                      - pass
                      type: object
                    progressDetails:
                      description: Describes the progress details of objects or actions
                        associated with the Component.
                      items:
                        properties:
                          actionName:
                            description: |-
                              Indicates the name of an OpsAction, as defined in `opsDefinition.spec.actions[*].name`.
                              Either `objectKey` or `actionName` must be provided.
                            type: string
                          actionTasks:
                            description: Lists the tasks, such as Jobs or Pods, that
                              carry out the action.
                            items:
                              properties:
                                namespace:
                                  description: Represents the namespace where the
                                    task is deployed.
                                  type: string
                                objectKey:
                                  description: Represents the name of the task.
                                  type: string
                                retries:
                                  description: The count of retry attempts made for
                                    this task.
                                  format: int32
                                  type: integer
                                status:
                                  description: Indicates the current status of the
                                    task, including "Processing", "Failed", "Succeed".
                                  enum:
                                  - Processing
                                  - Failed
                                  - Succeed
                                  type: string
                                targetPodName:
                                  description: The name of the Pod that the task is
                                    associated with or operates on.
                                  type: string
                              required:
                              - namespace
                              - objectKey
                              - status
                              type: object
                            type: array
                          endTime:
                            description: Records the completion time of object processing.
                            format: date-time
                            type: string
                          group:
                            description: Specifies the group to which the current
                              object belongs to.
                            type: string
                          message:
                            description: Provides a human-readable explanation of
                              the object's condition.
                            type: string
                          objectKey:
                            description: |-
                              `objectKey` uniquely identifies the object, which can be any K8s object, like a Pod, Job, Component, or PVC.
                              Either `objectKey` or `actionName` must be provided.
                            type: string
                          startTime:
                            description: Records the start time of object processing.
                            format: date-time
                            type: string
                          status:
                            description: Represents the current processing state of
                              the object, including "Processing", "Pending", "Failed",
                              "Succeed"
                            enum:
                            - Processing
                            - Pending
                            - Failed
                            - Succeed
                            type: string
                        required:
                        - status
                        type: object
                        x-kubernetes-validations:
                        - message: at least one objectKey or actionName.
                          rule: has(self.objectKey) || has(self.actionName)
                      type: array
                    reason:
                      description: Provides an explanation for the Component being
                        in its current state.
                      maxLength: 1024
                      type: string
                  type: object
                description: Records the status information of Components changed
                  due to the OpsRequest.
                type: object
              conditions:
                description: |-
                  Describes the detailed status of the OpsRequest.
                  Possible condition types include "Cancelled", "WaitForProgressing", "Validated", "Succeed", "Failed", "Restarting",
                  "VerticalScaling", "HorizontalScaling", "VolumeExpanding", "Reconfigure", "Switchover", "Stopping", "Starting",
                  "VersionUpgrading", "Exposing", "Backup", "InstancesRebuilding", "CustomOperation".
                items:
                  description: Condition contains details for one aspect of the current
                    state of this API Resource.
                  properties:
                    lastTransitionTime:
                      description: |-
                        lastTransitionTime is the last time the condition transitioned from one status to another.
                        This should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.
                      format: date-time
                      type: string
                    message:
                      description: |-
                        message is a human readable message indicating details about the transition.
                        This may be an empty string.
                      maxLength: 32768
                      type: string
                    observedGeneration:
                      description: |-
                        observedGeneration represents the .metadata.generation that the condition was set based upon.
                        For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date
                        with respect to the current state of the instance.
                      format: int64
                      minimum: 0
                      type: integer
                    reason:
                      description: |-
                        reason contains a programmatic identifier indicating the reason for the condition's last transition.
                        Producers of specific condition types may define expected values and meanings for this field,
                        and whether the values are considered a guaranteed API.
                        The value should be a CamelCase string.
                        This field may not be empty.
                      maxLength: 1024
                      minLength: 1
                      pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
                      type: string
                    status:
                      description: status of the condition, one of True, False, Unknown.
                      enum:
                      - "True"
                      - "False"
                      - Unknown
                      type: string
                    type:
                      description: type of condition in CamelCase or in foo.example.com/CamelCase.
                      maxLength: 316
                      pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
                      type: string
                  required:
                  - lastTransitionTime
                  - message
                  - reason
                  - status
                  - type
                  type: object
                type: array
                x-kubernetes-list-map-keys:
                - type
                x-kubernetes-list-type: map
              extras:
                description: A collection of additional key-value pairs that provide
                  supplementary information for the OpsRequest.
                items:
                  additionalProperties:
                    type: string
                  type: object
                type: array
              lastConfiguration:
                description: Records the configuration prior to any changes.
                properties:
                  components:
                    additionalProperties:
                      description: LastComponentConfiguration can be used to track
                        and compare the desired state of the Component over time.
                      properties:
                        claims:
                          description: |-
                            Claims lists the names of resources, defined in spec.resourceClaims,
                            that are used by this container.

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

                            This field is immutable. It can only be set for containers.
                          items:
                            description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                            properties:
                              name:
                                description: |-
                                  Name must match the name of one entry in pod.spec.resourceClaims of
                                  the Pod where this field is used. It makes that resource available
                                  inside a container.
                                type: string
                            required:
                            - name
                            type: object
                          type: array
                          x-kubernetes-list-map-keys:
                          - name
                          x-kubernetes-list-type: map
                        componentDefinitionName:
                          description: Records the name of the ComponentDefinition
                            prior to any changes.
                          type: string
                        instances:
                          description: Records the InstanceTemplate list of the Component
                            prior to any changes.
                          items:
                            description: InstanceTemplate allows customization of
                              individual replica configurations in a Component.
                            properties:
                              annotations:
                                additionalProperties:
                                  type: string
                                description: |-
                                  Specifies a map of key-value pairs to be merged into the Pod's existing annotations.
                                  Existing keys will have their values overwritten, while new keys will be added to the annotations.
                                type: object
                              canary:
                                description: Indicate whether the instances belonging
                                  to this template are canary instances.
                                type: boolean
                              compDef:
                                description: Specifies the name of the referenced
                                  ComponentDefinition.
                                maxLength: 64
                                type: string
                              env:
                                description: |-
                                  Defines Env to override.
                                  Add new or override existing envs.
                                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
                                              type: string
                                            optional:
                                              description: Specify whether the ConfigMap
                                                or its key must be defined
                                              type: boolean
                                          required:
                                          - key
                                          type: object
                                          x-kubernetes-map-type: atomic
                                        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
                                          x-kubernetes-map-type: atomic
                                        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
                                          x-kubernetes-map-type: atomic
                                        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
                                              type: string
                                            optional:
                                              description: Specify whether the Secret
                                                or its key must be defined
                                              type: boolean
                                          required:
                                          - key
                                          type: object
                                          x-kubernetes-map-type: atomic
                                      type: object
                                  required:
                                  - name
                                  type: object
                                type: array
                              labels:
                                additionalProperties:
                                  type: string
                                description: |-
                                  Specifies a map of key-value pairs that will be merged into the Pod's existing labels.
                                  Values for existing keys will be overwritten, and new keys will be added.
                                type: object
                              name:
                                description: |-
                                  Name specifies the unique name of the instance Pod created using this InstanceTemplate.
                                  This name is constructed by concatenating the Component's name, the template's name, and the instance's ordinal
                                  using the pattern: $(cluster.name)-$(component.name)-$(template.name)-$(ordinal). Ordinals start from 0.
                                  The name can't be empty.
                                maxLength: 54
                                pattern: ^[a-z0-9]([a-z0-9\.\-]*[a-z0-9])?$
                                type: string
                              ordinals:
                                description: |-
                                  Specifies the desired Ordinals of this InstanceTemplate.
                                  The Ordinals used to specify the ordinal of the instance (pod) names to be generated under this InstanceTemplate.
                                  If Ordinals are defined, their number must be equal to or more than the corresponding replicas.

                                  For example, if Ordinals is {ranges: [{start: 0, end: 1}], discrete: [7]},
                                  then the instance names generated under this InstanceTemplate would be
                                  $(cluster.name)-$(component.name)-$(template.name)-0、$(cluster.name)-$(component.name)-$(template.name)-1 and
                                  $(cluster.name)-$(component.name)-$(template.name)-7
                                properties:
                                  discrete:
                                    items:
                                      format: int32
                                      type: integer
                                    type: array
                                  ranges:
                                    items:
                                      description: |-
                                        Range represents a range with a start and an end value. Both start and end are included.
                                        It is used to define a continuous segment.
                                      properties:
                                        end:
                                          format: int32
                                          type: integer
                                        start:
                                          format: int32
                                          type: integer
                                      required:
                                      - end
                                      - start
                                      type: object
                                    type: array
                                type: object
                              replicas:
                                default: 1
                                description: |-
                                  Specifies the number of instances (Pods) to create from this InstanceTemplate.
                                  This field allows setting how many replicated instances of the Component,
                                  with the specific overrides in the InstanceTemplate, are created.
                                  The default value is 1. A value of 0 disables instance creation.
                                format: int32
                                minimum: 0
                                type: integer
                              resources:
                                description: |-
                                  Specifies an override for the resource requirements of the first container in the Pod.
                                  This field allows for customizing resource allocation (CPU, memory, etc.) for the container.
                                properties:
                                  claims:
                                    description: |-
                                      Claims lists the names of resources, defined in spec.resourceClaims,
                                      that are used by this container.

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

                                      This field is immutable. It can only be set for containers.
                                    items:
                                      description: ResourceClaim references one entry
                                        in PodSpec.ResourceClaims.
                                      properties:
                                        name:
                                          description: |-
                                            Name must match the name of one entry in pod.spec.resourceClaims of
                                            the Pod where this field is used. It makes that resource available
                                            inside a container.
                                          type: string
                                      required:
                                      - name
                                      type: object
                                    type: array
                                    x-kubernetes-list-map-keys:
                                    - name
                                    x-kubernetes-list-type: map
                                  limits:
                                    additionalProperties:
                                      anyOf:
                                      - type: integer
                                      - type: string
                                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                      x-kubernetes-int-or-string: true
                                    description: |-
                                      Limits describes the maximum amount of compute resources allowed.
                                      More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                    type: object
                                  requests:
                                    additionalProperties:
                                      anyOf:
                                      - type: integer
                                      - type: string
                                      pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                      x-kubernetes-int-or-string: true
                                    description: |-
                                      Requests describes the minimum amount of compute resources required.
                                      If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                                      otherwise to an implementation-defined value. Requests cannot exceed Limits.
                                      More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                    type: object
                                type: object
                              schedulingPolicy:
                                description: |-
                                  Specifies the scheduling policy for the instance.
                                  If defined, it will overwrite the scheduling policy defined in ClusterSpec and/or ClusterComponentSpec.
                                properties:
                                  affinity:
                                    description: Specifies a group of affinity scheduling
                                      rules of the Cluster, including NodeAffinity,
                                      PodAffinity, and PodAntiAffinity.
                                    properties:
                                      nodeAffinity:
                                        description: Describes node affinity scheduling
                                          rules for the pod.
                                        properties:
                                          preferredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              The scheduler will prefer to schedule pods to nodes that satisfy
                                              the affinity expressions specified by this field, but it may choose
                                              a node that violates one or more of the expressions. The node that is
                                              most preferred is the one with the greatest sum of weights, i.e.
                                              for each node that meets all of the scheduling requirements (resource
                                              request, requiredDuringScheduling affinity expressions, etc.),
                                              compute a sum by iterating through the elements of this field and adding
                                              "weight" to the sum if the node matches the corresponding matchExpressions; the
                                              node(s) with the highest sum are the most preferred.
                                            items:
                                              description: |-
                                                An empty preferred scheduling term matches all objects with implicit weight 0
                                                (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
                                              properties:
                                                preference:
                                                  description: A node selector term,
                                                    associated with the corresponding
                                                    weight.
                                                  properties:
                                                    matchExpressions:
                                                      description: A list of node
                                                        selector requirements by node's
                                                        labels.
                                                      items:
                                                        description: |-
                                                          A node selector requirement is a selector that contains values, a key, and an operator
                                                          that relates the key and values.
                                                        properties:
                                                          key:
                                                            description: The label
                                                              key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              Represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              An array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. If the operator is Gt or Lt, the values
                                                              array must have a single element, which will be interpreted as an integer.
                                                              This array is replaced during a strategic merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        required:
                                                        - key
                                                        - operator
                                                        type: object
                                                      type: array
                                                    matchFields:
                                                      description: A list of node
                                                        selector requirements by node's
                                                        fields.
                                                      items:
                                                        description: |-
                                                          A node selector requirement is a selector that contains values, a key, and an operator
                                                          that relates the key and values.
                                                        properties:
                                                          key:
                                                            description: The label
                                                              key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              Represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              An array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. If the operator is Gt or Lt, the values
                                                              array must have a single element, which will be interpreted as an integer.
                                                              This array is replaced during a strategic merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        required:
                                                        - key
                                                        - operator
                                                        type: object
                                                      type: array
                                                  type: object
                                                  x-kubernetes-map-type: atomic
                                                weight:
                                                  description: Weight associated with
                                                    matching the corresponding nodeSelectorTerm,
                                                    in the range 1-100.
                                                  format: int32
                                                  type: integer
                                              required:
                                              - preference
                                              - weight
                                              type: object
                                            type: array
                                          requiredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              If the affinity requirements specified by this field are not met at
                                              scheduling time, the pod will not be scheduled onto the node.
                                              If the affinity requirements specified by this field cease to be met
                                              at some point during pod execution (e.g. due to an update), the system
                                              may or may not try to eventually evict the pod from its node.
                                            properties:
                                              nodeSelectorTerms:
                                                description: Required. A list of node
                                                  selector terms. The terms are ORed.
                                                items:
                                                  description: |-
                                                    A null or empty node selector term matches no objects. The requirements of
                                                    them are ANDed.
                                                    The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
                                                  properties:
                                                    matchExpressions:
                                                      description: A list of node
                                                        selector requirements by node's
                                                        labels.
                                                      items:
                                                        description: |-
                                                          A node selector requirement is a selector that contains values, a key, and an operator
                                                          that relates the key and values.
                                                        properties:
                                                          key:
                                                            description: The label
                                                              key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              Represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              An array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. If the operator is Gt or Lt, the values
                                                              array must have a single element, which will be interpreted as an integer.
                                                              This array is replaced during a strategic merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        required:
                                                        - key
                                                        - operator
                                                        type: object
                                                      type: array
                                                    matchFields:
                                                      description: A list of node
                                                        selector requirements by node's
                                                        fields.
                                                      items:
                                                        description: |-
                                                          A node selector requirement is a selector that contains values, a key, and an operator
                                                          that relates the key and values.
                                                        properties:
                                                          key:
                                                            description: The label
                                                              key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              Represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              An array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. If the operator is Gt or Lt, the values
                                                              array must have a single element, which will be interpreted as an integer.
                                                              This array is replaced during a strategic merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        required:
                                                        - key
                                                        - operator
                                                        type: object
                                                      type: array
                                                  type: object
                                                  x-kubernetes-map-type: atomic
                                                type: array
                                            required:
                                            - nodeSelectorTerms
                                            type: object
                                            x-kubernetes-map-type: atomic
                                        type: object
                                      podAffinity:
                                        description: Describes pod affinity scheduling
                                          rules (e.g. co-locate this pod in the same
                                          node, zone, etc. as some other pod(s)).
                                        properties:
                                          preferredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              The scheduler will prefer to schedule pods to nodes that satisfy
                                              the affinity expressions specified by this field, but it may choose
                                              a node that violates one or more of the expressions. The node that is
                                              most preferred is the one with the greatest sum of weights, i.e.
                                              for each node that meets all of the scheduling requirements (resource
                                              request, requiredDuringScheduling affinity expressions, etc.),
                                              compute a sum by iterating through the elements of this field and adding
                                              "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                              node(s) with the highest sum are the most preferred.
                                            items:
                                              description: The weights of all of the
                                                matched WeightedPodAffinityTerm fields
                                                are added per-node to find the most
                                                preferred node(s)
                                              properties:
                                                podAffinityTerm:
                                                  description: Required. A pod affinity
                                                    term, associated with the corresponding
                                                    weight.
                                                  properties:
                                                    labelSelector:
                                                      description: |-
                                                        A label query over a set of resources, in this case pods.
                                                        If it's null, this PodAffinityTerm matches with no Pods.
                                                      properties:
                                                        matchExpressions:
                                                          description: matchExpressions
                                                            is a list of label selector
                                                            requirements. The requirements
                                                            are ANDed.
                                                          items:
                                                            description: |-
                                                              A label selector requirement is a selector that contains values, a key, and an operator that
                                                              relates the key and values.
                                                            properties:
                                                              key:
                                                                description: key is
                                                                  the label key that
                                                                  the selector applies
                                                                  to.
                                                                type: string
                                                              operator:
                                                                description: |-
                                                                  operator represents a key's relationship to a set of values.
                                                                  Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                type: string
                                                              values:
                                                                description: |-
                                                                  values is an array of string values. If the operator is In or NotIn,
                                                                  the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                  the values array must be empty. This array is replaced during a strategic
                                                                  merge patch.
                                                                items:
                                                                  type: string
                                                                type: array
                                                            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
                                                      x-kubernetes-map-type: atomic
                                                    matchLabelKeys:
                                                      description: |-
                                                        MatchLabelKeys is a set of pod label keys to select which pods will
                                                        be taken into consideration. The keys are used to lookup values from the
                                                        incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)`
                                                        to select the group of existing pods which pods will be taken into consideration
                                                        for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                        pod labels will be ignored. The default value is empty.
                                                        The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                                        Also, MatchLabelKeys cannot be set when LabelSelector isn't set.
                                                        This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                      items:
                                                        type: string
                                                      type: array
                                                      x-kubernetes-list-type: atomic
                                                    mismatchLabelKeys:
                                                      description: |-
                                                        MismatchLabelKeys is a set of pod label keys to select which pods will
                                                        be taken into consideration. The keys are used to lookup values from the
                                                        incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)`
                                                        to select the group of existing pods which pods will be taken into consideration
                                                        for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                        pod labels will be ignored. The default value is empty.
                                                        The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector.
                                                        Also, MismatchLabelKeys cannot be set when LabelSelector isn't set.
                                                        This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                      items:
                                                        type: string
                                                      type: array
                                                      x-kubernetes-list-type: atomic
                                                    namespaceSelector:
                                                      description: |-
                                                        A label query over the set of namespaces that the term applies to.
                                                        The term is applied to the union of the namespaces selected by this field
                                                        and the ones listed in the namespaces field.
                                                        null selector and null or empty namespaces list means "this pod's namespace".
                                                        An empty selector ({}) matches all namespaces.
                                                      properties:
                                                        matchExpressions:
                                                          description: matchExpressions
                                                            is a list of label selector
                                                            requirements. The requirements
                                                            are ANDed.
                                                          items:
                                                            description: |-
                                                              A label selector requirement is a selector that contains values, a key, and an operator that
                                                              relates the key and values.
                                                            properties:
                                                              key:
                                                                description: key is
                                                                  the label key that
                                                                  the selector applies
                                                                  to.
                                                                type: string
                                                              operator:
                                                                description: |-
                                                                  operator represents a key's relationship to a set of values.
                                                                  Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                type: string
                                                              values:
                                                                description: |-
                                                                  values is an array of string values. If the operator is In or NotIn,
                                                                  the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                  the values array must be empty. This array is replaced during a strategic
                                                                  merge patch.
                                                                items:
                                                                  type: string
                                                                type: array
                                                            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
                                                      x-kubernetes-map-type: atomic
                                                    namespaces:
                                                      description: |-
                                                        namespaces specifies a static list of namespace names that the term applies to.
                                                        The term is applied to the union of the namespaces listed in this field
                                                        and the ones selected by namespaceSelector.
                                                        null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                      items:
                                                        type: string
                                                      type: array
                                                    topologyKey:
                                                      description: |-
                                                        This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                        the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                        whose value of the label with key topologyKey matches that of any node on which any of the
                                                        selected pods is running.
                                                        Empty topologyKey is not allowed.
                                                      type: string
                                                  required:
                                                  - topologyKey
                                                  type: object
                                                weight:
                                                  description: |-
                                                    weight associated with matching the corresponding podAffinityTerm,
                                                    in the range 1-100.
                                                  format: int32
                                                  type: integer
                                              required:
                                              - podAffinityTerm
                                              - weight
                                              type: object
                                            type: array
                                          requiredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              If the affinity requirements specified by this field are not met at
                                              scheduling time, the pod will not be scheduled onto the node.
                                              If the affinity requirements specified by this field cease to be met
                                              at some point during pod execution (e.g. due to a pod label update), the
                                              system may or may not try to eventually evict the pod from its node.
                                              When there are multiple elements, the lists of nodes corresponding to each
                                              podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                            items:
                                              description: |-
                                                Defines a set of pods (namely those matching the labelSelector
                                                relative to the given namespace(s)) that this pod should be
                                                co-located (affinity) or not co-located (anti-affinity) with,
                                                where co-located is defined as running on a node whose value of
                                                the label with key <topologyKey> matches that of any node on which
                                                a pod of the set of pods is running
                                              properties:
                                                labelSelector:
                                                  description: |-
                                                    A label query over a set of resources, in this case pods.
                                                    If it's null, this PodAffinityTerm matches with no Pods.
                                                  properties:
                                                    matchExpressions:
                                                      description: matchExpressions
                                                        is a list of label selector
                                                        requirements. The requirements
                                                        are ANDed.
                                                      items:
                                                        description: |-
                                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                                          relates the key and values.
                                                        properties:
                                                          key:
                                                            description: key is the
                                                              label key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              operator represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              values is an array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. This array is replaced during a strategic
                                                              merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        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
                                                  x-kubernetes-map-type: atomic
                                                matchLabelKeys:
                                                  description: |-
                                                    MatchLabelKeys is a set of pod label keys to select which pods will
                                                    be taken into consideration. The keys are used to lookup values from the
                                                    incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)`
                                                    to select the group of existing pods which pods will be taken into consideration
                                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                    pod labels will be ignored. The default value is empty.
                                                    The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                                    Also, MatchLabelKeys cannot be set when LabelSelector isn't set.
                                                    This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                                mismatchLabelKeys:
                                                  description: |-
                                                    MismatchLabelKeys is a set of pod label keys to select which pods will
                                                    be taken into consideration. The keys are used to lookup values from the
                                                    incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)`
                                                    to select the group of existing pods which pods will be taken into consideration
                                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                    pod labels will be ignored. The default value is empty.
                                                    The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector.
                                                    Also, MismatchLabelKeys cannot be set when LabelSelector isn't set.
                                                    This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                                namespaceSelector:
                                                  description: |-
                                                    A label query over the set of namespaces that the term applies to.
                                                    The term is applied to the union of the namespaces selected by this field
                                                    and the ones listed in the namespaces field.
                                                    null selector and null or empty namespaces list means "this pod's namespace".
                                                    An empty selector ({}) matches all namespaces.
                                                  properties:
                                                    matchExpressions:
                                                      description: matchExpressions
                                                        is a list of label selector
                                                        requirements. The requirements
                                                        are ANDed.
                                                      items:
                                                        description: |-
                                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                                          relates the key and values.
                                                        properties:
                                                          key:
                                                            description: key is the
                                                              label key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              operator represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              values is an array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. This array is replaced during a strategic
                                                              merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        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
                                                  x-kubernetes-map-type: atomic
                                                namespaces:
                                                  description: |-
                                                    namespaces specifies a static list of namespace names that the term applies to.
                                                    The term is applied to the union of the namespaces listed in this field
                                                    and the ones selected by namespaceSelector.
                                                    null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                  items:
                                                    type: string
                                                  type: array
                                                topologyKey:
                                                  description: |-
                                                    This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                    the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                    whose value of the label with key topologyKey matches that of any node on which any of the
                                                    selected pods is running.
                                                    Empty topologyKey is not allowed.
                                                  type: string
                                              required:
                                              - topologyKey
                                              type: object
                                            type: array
                                        type: object
                                      podAntiAffinity:
                                        description: Describes pod anti-affinity scheduling
                                          rules (e.g. avoid putting this pod in the
                                          same node, zone, etc. as some other pod(s)).
                                        properties:
                                          preferredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              The scheduler will prefer to schedule pods to nodes that satisfy
                                              the anti-affinity expressions specified by this field, but it may choose
                                              a node that violates one or more of the expressions. The node that is
                                              most preferred is the one with the greatest sum of weights, i.e.
                                              for each node that meets all of the scheduling requirements (resource
                                              request, requiredDuringScheduling anti-affinity expressions, etc.),
                                              compute a sum by iterating through the elements of this field and adding
                                              "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
                                              node(s) with the highest sum are the most preferred.
                                            items:
                                              description: The weights of all of the
                                                matched WeightedPodAffinityTerm fields
                                                are added per-node to find the most
                                                preferred node(s)
                                              properties:
                                                podAffinityTerm:
                                                  description: Required. A pod affinity
                                                    term, associated with the corresponding
                                                    weight.
                                                  properties:
                                                    labelSelector:
                                                      description: |-
                                                        A label query over a set of resources, in this case pods.
                                                        If it's null, this PodAffinityTerm matches with no Pods.
                                                      properties:
                                                        matchExpressions:
                                                          description: matchExpressions
                                                            is a list of label selector
                                                            requirements. The requirements
                                                            are ANDed.
                                                          items:
                                                            description: |-
                                                              A label selector requirement is a selector that contains values, a key, and an operator that
                                                              relates the key and values.
                                                            properties:
                                                              key:
                                                                description: key is
                                                                  the label key that
                                                                  the selector applies
                                                                  to.
                                                                type: string
                                                              operator:
                                                                description: |-
                                                                  operator represents a key's relationship to a set of values.
                                                                  Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                type: string
                                                              values:
                                                                description: |-
                                                                  values is an array of string values. If the operator is In or NotIn,
                                                                  the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                  the values array must be empty. This array is replaced during a strategic
                                                                  merge patch.
                                                                items:
                                                                  type: string
                                                                type: array
                                                            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
                                                      x-kubernetes-map-type: atomic
                                                    matchLabelKeys:
                                                      description: |-
                                                        MatchLabelKeys is a set of pod label keys to select which pods will
                                                        be taken into consideration. The keys are used to lookup values from the
                                                        incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)`
                                                        to select the group of existing pods which pods will be taken into consideration
                                                        for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                        pod labels will be ignored. The default value is empty.
                                                        The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                                        Also, MatchLabelKeys cannot be set when LabelSelector isn't set.
                                                        This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                      items:
                                                        type: string
                                                      type: array
                                                      x-kubernetes-list-type: atomic
                                                    mismatchLabelKeys:
                                                      description: |-
                                                        MismatchLabelKeys is a set of pod label keys to select which pods will
                                                        be taken into consideration. The keys are used to lookup values from the
                                                        incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)`
                                                        to select the group of existing pods which pods will be taken into consideration
                                                        for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                        pod labels will be ignored. The default value is empty.
                                                        The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector.
                                                        Also, MismatchLabelKeys cannot be set when LabelSelector isn't set.
                                                        This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                      items:
                                                        type: string
                                                      type: array
                                                      x-kubernetes-list-type: atomic
                                                    namespaceSelector:
                                                      description: |-
                                                        A label query over the set of namespaces that the term applies to.
                                                        The term is applied to the union of the namespaces selected by this field
                                                        and the ones listed in the namespaces field.
                                                        null selector and null or empty namespaces list means "this pod's namespace".
                                                        An empty selector ({}) matches all namespaces.
                                                      properties:
                                                        matchExpressions:
                                                          description: matchExpressions
                                                            is a list of label selector
                                                            requirements. The requirements
                                                            are ANDed.
                                                          items:
                                                            description: |-
                                                              A label selector requirement is a selector that contains values, a key, and an operator that
                                                              relates the key and values.
                                                            properties:
                                                              key:
                                                                description: key is
                                                                  the label key that
                                                                  the selector applies
                                                                  to.
                                                                type: string
                                                              operator:
                                                                description: |-
                                                                  operator represents a key's relationship to a set of values.
                                                                  Valid operators are In, NotIn, Exists and DoesNotExist.
                                                                type: string
                                                              values:
                                                                description: |-
                                                                  values is an array of string values. If the operator is In or NotIn,
                                                                  the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                                  the values array must be empty. This array is replaced during a strategic
                                                                  merge patch.
                                                                items:
                                                                  type: string
                                                                type: array
                                                            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
                                                      x-kubernetes-map-type: atomic
                                                    namespaces:
                                                      description: |-
                                                        namespaces specifies a static list of namespace names that the term applies to.
                                                        The term is applied to the union of the namespaces listed in this field
                                                        and the ones selected by namespaceSelector.
                                                        null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                      items:
                                                        type: string
                                                      type: array
                                                    topologyKey:
                                                      description: |-
                                                        This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                        the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                        whose value of the label with key topologyKey matches that of any node on which any of the
                                                        selected pods is running.
                                                        Empty topologyKey is not allowed.
                                                      type: string
                                                  required:
                                                  - topologyKey
                                                  type: object
                                                weight:
                                                  description: |-
                                                    weight associated with matching the corresponding podAffinityTerm,
                                                    in the range 1-100.
                                                  format: int32
                                                  type: integer
                                              required:
                                              - podAffinityTerm
                                              - weight
                                              type: object
                                            type: array
                                          requiredDuringSchedulingIgnoredDuringExecution:
                                            description: |-
                                              If the anti-affinity requirements specified by this field are not met at
                                              scheduling time, the pod will not be scheduled onto the node.
                                              If the anti-affinity requirements specified by this field cease to be met
                                              at some point during pod execution (e.g. due to a pod label update), the
                                              system may or may not try to eventually evict the pod from its node.
                                              When there are multiple elements, the lists of nodes corresponding to each
                                              podAffinityTerm are intersected, i.e. all terms must be satisfied.
                                            items:
                                              description: |-
                                                Defines a set of pods (namely those matching the labelSelector
                                                relative to the given namespace(s)) that this pod should be
                                                co-located (affinity) or not co-located (anti-affinity) with,
                                                where co-located is defined as running on a node whose value of
                                                the label with key <topologyKey> matches that of any node on which
                                                a pod of the set of pods is running
                                              properties:
                                                labelSelector:
                                                  description: |-
                                                    A label query over a set of resources, in this case pods.
                                                    If it's null, this PodAffinityTerm matches with no Pods.
                                                  properties:
                                                    matchExpressions:
                                                      description: matchExpressions
                                                        is a list of label selector
                                                        requirements. The requirements
                                                        are ANDed.
                                                      items:
                                                        description: |-
                                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                                          relates the key and values.
                                                        properties:
                                                          key:
                                                            description: key is the
                                                              label key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              operator represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              values is an array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. This array is replaced during a strategic
                                                              merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        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
                                                  x-kubernetes-map-type: atomic
                                                matchLabelKeys:
                                                  description: |-
                                                    MatchLabelKeys is a set of pod label keys to select which pods will
                                                    be taken into consideration. The keys are used to lookup values from the
                                                    incoming pod labels, those key-value labels are merged with `LabelSelector` as `key in (value)`
                                                    to select the group of existing pods which pods will be taken into consideration
                                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                    pod labels will be ignored. The default value is empty.
                                                    The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                                    Also, MatchLabelKeys cannot be set when LabelSelector isn't set.
                                                    This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                                mismatchLabelKeys:
                                                  description: |-
                                                    MismatchLabelKeys is a set of pod label keys to select which pods will
                                                    be taken into consideration. The keys are used to lookup values from the
                                                    incoming pod labels, those key-value labels are merged with `LabelSelector` as `key notin (value)`
                                                    to select the group of existing pods which pods will be taken into consideration
                                                    for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
                                                    pod labels will be ignored. The default value is empty.
                                                    The same key is forbidden to exist in both MismatchLabelKeys and LabelSelector.
                                                    Also, MismatchLabelKeys cannot be set when LabelSelector isn't set.
                                                    This is an alpha field and requires enabling MatchLabelKeysInPodAffinity feature gate.
                                                  items:
                                                    type: string
                                                  type: array
                                                  x-kubernetes-list-type: atomic
                                                namespaceSelector:
                                                  description: |-
                                                    A label query over the set of namespaces that the term applies to.
                                                    The term is applied to the union of the namespaces selected by this field
                                                    and the ones listed in the namespaces field.
                                                    null selector and null or empty namespaces list means "this pod's namespace".
                                                    An empty selector ({}) matches all namespaces.
                                                  properties:
                                                    matchExpressions:
                                                      description: matchExpressions
                                                        is a list of label selector
                                                        requirements. The requirements
                                                        are ANDed.
                                                      items:
                                                        description: |-
                                                          A label selector requirement is a selector that contains values, a key, and an operator that
                                                          relates the key and values.
                                                        properties:
                                                          key:
                                                            description: key is the
                                                              label key that the selector
                                                              applies to.
                                                            type: string
                                                          operator:
                                                            description: |-
                                                              operator represents a key's relationship to a set of values.
                                                              Valid operators are In, NotIn, Exists and DoesNotExist.
                                                            type: string
                                                          values:
                                                            description: |-
                                                              values is an array of string values. If the operator is In or NotIn,
                                                              the values array must be non-empty. If the operator is Exists or DoesNotExist,
                                                              the values array must be empty. This array is replaced during a strategic
                                                              merge patch.
                                                            items:
                                                              type: string
                                                            type: array
                                                        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
                                                  x-kubernetes-map-type: atomic
                                                namespaces:
                                                  description: |-
                                                    namespaces specifies a static list of namespace names that the term applies to.
                                                    The term is applied to the union of the namespaces listed in this field
                                                    and the ones selected by namespaceSelector.
                                                    null or empty namespaces list and null namespaceSelector means "this pod's namespace".
                                                  items:
                                                    type: string
                                                  type: array
                                                topologyKey:
                                                  description: |-
                                                    This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
                                                    the labelSelector in the specified namespaces, where co-located is defined as running on a node
                                                    whose value of the label with key topologyKey matches that of any node on which any of the
                                                    selected pods is running.
                                                    Empty topologyKey is not allowed.
                                                  type: string
                                              required:
                                              - topologyKey
                                              type: object
                                            type: array
                                        type: object
                                    type: object
                                  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
                                  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
                                  tolerations:
                                    description: |-
                                      Allows Pods to be scheduled onto nodes with matching taints.
                                      Each toleration in the array allows the Pod to tolerate node taints based on
                                      specified `key`, `value`, `effect`, and `operator`.

                                      - The `key`, `value`, and `effect` identify the taint that the toleration matches.
                                      - The `operator` determines how the toleration matches the taint.

                                      Pods with matching tolerations are allowed to be scheduled on tainted nodes, typically reserved for specific purposes.
                                    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
                                          x-kubernetes-map-type: atomic
                                        matchLabelKeys:
                                          description: |-
                                            MatchLabelKeys is a set of pod label keys to select the pods over which
                                            spreading will be calculated. The keys are used to lookup values from the
                                            incoming pod labels, those key-value labels are ANDed with labelSelector
                                            to select the group of existing pods over which spreading will be calculated
                                            for the incoming pod. The same key is forbidden to exist in both MatchLabelKeys and LabelSelector.
                                            MatchLabelKeys cannot be set when LabelSelector isn't set.
                                            Keys that don't exist in the incoming pod labels will
                                            be ignored. A null or empty list means only match against labelSelector.

                                            This is a beta field and requires the MatchLabelKeysInPodTopologySpread feature gate to be enabled (enabled by default).
                                          items:
                                            type: string
                                          type: array
                                          x-kubernetes-list-type: atomic
                                        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.
                                            The global minimum is the minimum number of matching pods in an eligible domain
                                            or zero if the number of eligible domains is less than MinDomains.
                                            For example, in a 3-zone cluster, MaxSkew is set to 1, and pods with the same
                                            labelSelector spread as 2/2/1:
                                            In this case, the global minimum is 1.
                                            | zone1 | zone2 | zone3 |
                                            |  P P  |  P P  |   P   |
                                            - if MaxSkew is 1, incoming pod can only be scheduled to zone3 to become 2/2/2;
                                            scheduling it onto zone1(zone2) would make the ActualSkew(3-1) 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
                                        minDomains:
                                          description: |-
                                            MinDomains indicates a minimum number of eligible domains.
                                            When the number of eligible domains with matching topology keys is less than minDomains,
                                            Pod Topology Spread treats "global minimum" as 0, and then the calculation of Skew is performed.
                                            And when the number of eligible domains with matching topology keys equals or greater than minDomains,
                                            this value has no effect on scheduling.
                                            As a result, when the number of eligible domains is less than minDomains,
                                            scheduler won't schedule more than maxSkew Pods to those domains.
                                            If value is nil, the constraint behaves as if MinDomains is equal to 1.
                                            Valid values are integers greater than 0.
                                            When value is not nil, WhenUnsatisfiable must be DoNotSchedule.

                                            For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same
                                            labelSelector spread as 2/2/2:
                                            | zone1 | zone2 | zone3 |
                                            |  P P  |  P P  |  P P  |
                                            The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0.
                                            In this situation, new pod with the same labelSelector cannot be scheduled,
                                            because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones,
                                            it will violate MaxSkew.

                                            This is a beta field and requires the MinDomainsInPodTopologySpread feature gate to be enabled (enabled by default).
                                          format: int32
                                          type: integer
                                        nodeAffinityPolicy:
                                          description: |-
                                            NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector
                                            when calculating pod topology spread skew. Options are:
                                            - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations.
                                            - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.

                                            If this value is nil, the behavior is equivalent to the Honor policy.
                                            This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
                                          type: string
                                        nodeTaintsPolicy:
                                          description: |-
                                            NodeTaintsPolicy indicates how we will treat node taints when calculating
                                            pod topology spread skew. Options are:
                                            - Honor: nodes without taints, along with tainted nodes for which the incoming pod
                                            has a toleration, are included.
                                            - Ignore: node taints are ignored. All nodes are included.

                                            If this value is nil, the behavior is equivalent to the Ignore policy.
                                            This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
                                          type: string
                                        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.
                                            We define a domain as a particular instance of a topology.
                                            Also, we define an eligible domain as a domain whose nodes meet the requirements of
                                            nodeAffinityPolicy and nodeTaintsPolicy.
                                            e.g. If TopologyKey is "kubernetes.io/hostname", each Node is a domain of that topology.
                                            And, if TopologyKey is "topology.kubernetes.io/zone", each zone is a domain of that topology.
                                            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
                                type: object
                              serviceVersion:
                                description: |-
                                  ServiceVersion specifies the version of the Service expected to be provisioned by this InstanceTemplate.
                                  The version should follow the syntax and semantics of the "Semantic Versioning" specification (http://semver.org/).
                                maxLength: 32
                                type: string
                              volumeClaimTemplates:
                                description: Specifies an override for the storage
                                  requirements of the instances.
                                items:
                                  properties:
                                    annotations:
                                      additionalProperties:
                                        type: string
                                      description: Specifies the annotations for the
                                        PVC of the volume.
                                      type: object
                                    labels:
                                      additionalProperties:
                                        type: string
                                      description: Specifies the labels for the PVC
                                        of the volume.
                                      type: object
                                    name:
                                      description: |-
                                        Refers to the name of a volumeMount defined in either:

                                        - `componentDefinition.spec.runtime.containers[*].volumeMounts`

                                        The value of `name` must match the `name` field of a volumeMount specified in the corresponding `volumeMounts` array.
                                      type: string
                                    persistentVolumeClaimName:
                                      description: |-
                                        Specifies the prefix of the PVC name for the volume.

                                        For each replica, the final name of the PVC will be in format: <persistentVolumeClaimName>-<ordinal>
                                      type: string
                                    spec:
                                      description: |-
                                        Defines the desired characteristics of a PersistentVolumeClaim that will be created for the volume
                                        with the mount name specified in the `name` field.
                                      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
                                        dataSource:
                                          description: |-
                                            dataSource field can be used to specify either:
                                            * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)
                                            * An existing PVC (PersistentVolumeClaim)
                                            If the provisioner or an external controller can support the specified data source,
                                            it will create a new volume based on the contents of the specified data source.
                                            When the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef,
                                            and dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified.
                                            If the namespace is specified, then dataSourceRef will not be copied to dataSource.
                                          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
                                          x-kubernetes-map-type: atomic
                                        dataSourceRef:
                                          description: |-
                                            dataSourceRef specifies the object from which to populate the volume with data, if a non-empty
                                            volume is desired. This may be any 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, when namespace isn't specified in dataSourceRef,
                                            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.
                                            When namespace is specified in dataSourceRef,
                                            dataSource isn't set to the same value and must be empty.
                                            There are three 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.
                                            * While dataSource only allows local objects, dataSourceRef allows objects
                                              in any namespaces.
                                            (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.
                                            (Alpha) Using the namespace field of dataSourceRef requires the CrossNamespaceVolumeDataSource 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
                                            namespace:
                                              description: |-
                                                Namespace is the namespace of resource being referenced
                                                Note that when a namespace is specified, a gateway.networking.k8s.io/ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details.
                                                (Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.
                                              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. Requests cannot exceed Limits.
                                                More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                                              type: object
                                          type: object
                                        selector:
                                          description: selector is 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
                                          x-kubernetes-map-type: atomic
                                        storageClassName:
                                          description: |-
                                            storageClassName is the name of the StorageClass required by the claim.
                                            More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1
                                          type: string
                                        volumeAttributesClassName:
                                          description: |-
                                            volumeAttributesClassName may be used to set the VolumeAttributesClass used by this claim.
                                            If specified, the CSI driver will create or update the volume with the attributes defined
                                            in the corresponding VolumeAttributesClass. This has a different purpose than storageClassName,
                                            it can be changed after the claim is created. An empty string value means that no VolumeAttributesClass
                                            will be applied to the claim but it's not allowed to reset this field to empty string once it is set.
                                            If unspecified and the PersistentVolumeClaim is unbound, the default VolumeAttributesClass
                                            will be set by the persistentvolume controller if it exists.
                                            If the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be
                                            set to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource
                                            exists.
                                            More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#volumeattributesclass
                                            (Alpha) Using this field requires the VolumeAttributesClass feature gate to be enabled.
                                          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:
                                  - name
                                  type: object
                                type: array
                            required:
                            - name
                            type: object
                          type: array
                        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
                        offlineInstances:
                          description: Records the offline instances of the Component
                            prior to any changes.
                          items:
                            type: string
                          type: array
                        replicas:
                          description: Records the `replicas` of the Component prior
                            to any changes.
                          format: int32
                          type: integer
                        requests:
                          additionalProperties:
                            anyOf:
                            - type: integer
                            - type: string
                            pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                            x-kubernetes-int-or-string: true
                          description: |-
                            Requests describes the minimum amount of compute resources required.
                            If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
                            otherwise to an implementation-defined value. Requests cannot exceed Limits.
                            More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
                          type: object
                        serviceVersion:
                          description: Records the version of the Service expected
                            to be provisioned by this Component prior to any changes.
                          type: string
                        services:
                          description: Records the ClusterComponentService list of
                            the Component prior to any changes.
                          items:
                            properties:
                              annotations:
                                additionalProperties:
                                  type: string
                                description: |-
                                  If ServiceType is LoadBalancer, cloud provider related parameters can be put here.
                                  More info: https://kubernetes.io/docs/concepts/services-networking/service/#loadbalancer.
                                type: object
                              name:
                                description: References the ComponentService name
                                  defined in the `componentDefinition.spec.services[*].name`.
                                maxLength: 25
                                type: string
                              podService:
                                default: false
                                description: |-
                                  Indicates whether to generate individual Services for each Pod.
                                  If set to true, a separate Service will be created for each Pod in the Cluster.
                                type: boolean
                              serviceType:
                                default: ClusterIP
                                description: |-
                                  Determines how the Service is exposed. Valid options are `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,
                                     they are determined by manual construction of an Endpoints object or EndpointSlice objects.
                                  - `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.

                                  Note: although K8s Service type allows the 'ExternalName' type, it is not a valid option for ClusterComponentService.

                                  For more info, see:
                                  https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types.
                                enum:
                                - ClusterIP
                                - NodePort
                                - LoadBalancer
                                type: string
                                x-kubernetes-preserve-unknown-fields: true
                            required:
                            - name
                            type: object
                          type: array
                        shards:
                          description: Records the `shards` of the Component prior
                            to any changes.
                          format: int32
                          type: integer
                        volumeClaimTemplates:
                          description: Records volumes' storage size of the Component
                            prior to any changes.
                          items:
                            properties:
                              name:
                                description: |-
                                  Specify the name of the volumeClaimTemplate in the Component.
                                  The specified name must match one of the volumeClaimTemplates defined
                                  in the `clusterComponentSpec.volumeClaimTemplates` field.
                                type: string
                              storage:
                                anyOf:
                                - type: integer
                                - type: string
                                description: Specifies the desired storage size for
                                  the volume.
                                pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                x-kubernetes-int-or-string: true
                            required:
                            - name
                            - storage
                            type: object
                          type: array
                      type: object
                      x-kubernetes-preserve-unknown-fields: true
                    description: Records the configuration of each Component prior
                      to any changes.
                    type: object
                type: object
              phase:
                description: |-
                  Represents the phase of the OpsRequest.
                  Possible values include "Pending", "Creating", "Running", "Cancelling", "Cancelled", "Failed", "Succeed".
                enum:
                - Pending
                - Creating
                - Running
                - Cancelling
                - Cancelled
                - Aborted
                - Failed
                - Succeed
                type: string
              progress:
                default: -/-
                description: Represents the progress of the OpsRequest.
                pattern: ^(\d+|\-)/(\d+|\-)$
                type: string
              startTimestamp:
                description: Records the time when the OpsRequest started processing.
                format: date-time
                type: string
            required:
            - progress
            type: object
        type: object
    served: true
    storage: true
    subresources:
      status: {}