cephcluster_v1.json

{
  "description": "CephCluster is a Ceph storage cluster",
  "properties": {
    "apiVersion": {
      "description": "APIVersion defines the versioned schema of this representation of an object.\nServers should convert recognized schemas to the latest internal value, and\nmay reject unrecognized values.\nMore 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.\nServers may infer this from the endpoint the client submits requests to.\nCannot be updated.\nIn CamelCase.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
      "type": "string"
    },
    "metadata": {
      "type": "object"
    },
    "spec": {
      "description": "ClusterSpec represents the specification of Ceph Cluster",
      "properties": {
        "annotations": {
          "additionalProperties": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Annotations are annotations",
            "type": "object"
          },
          "description": "The annotations-related configuration to add/set on each Pod related object.",
          "nullable": true,
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "cephConfig": {
          "additionalProperties": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object"
          },
          "description": "Ceph Config options",
          "nullable": true,
          "type": "object"
        },
        "cephVersion": {
          "description": "The version information that instructs Rook to orchestrate a particular version of Ceph.",
          "nullable": true,
          "properties": {
            "allowUnsupported": {
              "description": "Whether to allow unsupported versions (do not set to true in production)",
              "type": "boolean"
            },
            "image": {
              "description": "Image is the container image used to launch the ceph daemons, such as quay.io/ceph/ceph:<tag>\nThe full list of images can be found at https://quay.io/repository/ceph/ceph?tab=tags",
              "type": "string"
            },
            "imagePullPolicy": {
              "description": "ImagePullPolicy describes a policy for if/when to pull a container image\nOne of Always, Never, IfNotPresent.",
              "enum": [
                "IfNotPresent",
                "Always",
                "Never",
                ""
              ],
              "type": "string"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "cleanupPolicy": {
          "description": "Indicates user intent when deleting a cluster; blocks orchestration and should not be set if cluster\ndeletion is not imminent.",
          "nullable": true,
          "properties": {
            "allowUninstallWithVolumes": {
              "description": "AllowUninstallWithVolumes defines whether we can proceed with the uninstall if they are RBD images still present",
              "type": "boolean"
            },
            "confirmation": {
              "description": "Confirmation represents the cleanup confirmation",
              "nullable": true,
              "pattern": "^$|^yes-really-destroy-data$",
              "type": "string"
            },
            "sanitizeDisks": {
              "description": "SanitizeDisks represents way we sanitize disks",
              "nullable": true,
              "properties": {
                "dataSource": {
                  "description": "DataSource is the data source to use to sanitize the disk with",
                  "enum": [
                    "zero",
                    "random"
                  ],
                  "type": "string"
                },
                "iteration": {
                  "description": "Iteration is the number of pass to apply the sanitizing",
                  "format": "int32",
                  "type": "integer"
                },
                "method": {
                  "description": "Method is the method we use to sanitize disks",
                  "enum": [
                    "complete",
                    "quick"
                  ],
                  "type": "string"
                }
              },
              "type": "object",
              "additionalProperties": false
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "continueUpgradeAfterChecksEvenIfNotHealthy": {
          "description": "ContinueUpgradeAfterChecksEvenIfNotHealthy defines if an upgrade should continue even if PGs are not clean",
          "type": "boolean"
        },
        "crashCollector": {
          "description": "A spec for the crash controller",
          "nullable": true,
          "properties": {
            "daysToRetain": {
              "description": "DaysToRetain represents the number of days to retain crash until they get pruned",
              "type": "integer"
            },
            "disable": {
              "description": "Disable determines whether we should enable the crash collector",
              "type": "boolean"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "csi": {
          "description": "CSI Driver Options applied per cluster.",
          "properties": {
            "cephfs": {
              "description": "CephFS defines CSI Driver settings for CephFS driver.",
              "properties": {
                "fuseMountOptions": {
                  "description": "FuseMountOptions defines the mount options for ceph fuse mounter.",
                  "type": "string"
                },
                "kernelMountOptions": {
                  "description": "KernelMountOptions defines the mount options for kernel mounter.",
                  "type": "string"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "readAffinity": {
              "description": "ReadAffinity defines the read affinity settings for CSI driver.",
              "properties": {
                "crushLocationLabels": {
                  "description": "CrushLocationLabels defines which node labels to use\nas CRUSH location. This should correspond to the values set in\nthe CRUSH map.",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                },
                "enabled": {
                  "description": "Enables read affinity for CSI driver.",
                  "type": "boolean"
                }
              },
              "type": "object",
              "additionalProperties": false
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "dashboard": {
          "description": "Dashboard settings",
          "nullable": true,
          "properties": {
            "enabled": {
              "description": "Enabled determines whether to enable the dashboard",
              "type": "boolean"
            },
            "port": {
              "description": "Port is the dashboard webserver port",
              "maximum": 65535,
              "minimum": 0,
              "type": "integer"
            },
            "prometheusEndpoint": {
              "description": "Endpoint for the Prometheus host",
              "type": "string"
            },
            "prometheusEndpointSSLVerify": {
              "description": "Whether to verify the ssl endpoint for prometheus. Set to false for a self-signed cert.",
              "type": "boolean"
            },
            "ssl": {
              "description": "SSL determines whether SSL should be used",
              "type": "boolean"
            },
            "urlPrefix": {
              "description": "URLPrefix is a prefix for all URLs to use the dashboard with a reverse proxy",
              "type": "string"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "dataDirHostPath": {
          "description": "The path on the host where config and data can be persisted",
          "pattern": "^/(\\S+)",
          "type": "string",
          "x-kubernetes-validations": [
            {
              "message": "DataDirHostPath is immutable",
              "rule": "self == oldSelf"
            }
          ]
        },
        "disruptionManagement": {
          "description": "A spec for configuring disruption management.",
          "nullable": true,
          "properties": {
            "machineDisruptionBudgetNamespace": {
              "description": "Deprecated. Namespace to look for MDBs by the machineDisruptionBudgetController",
              "type": "string"
            },
            "manageMachineDisruptionBudgets": {
              "description": "Deprecated. This enables management of machinedisruptionbudgets.",
              "type": "boolean"
            },
            "managePodBudgets": {
              "description": "This enables management of poddisruptionbudgets",
              "type": "boolean"
            },
            "osdMaintenanceTimeout": {
              "description": "OSDMaintenanceTimeout sets how many additional minutes the DOWN/OUT interval is for drained failure domains\nit only works if managePodBudgets is true.\nthe default is 30 minutes",
              "format": "int64",
              "type": "integer"
            },
            "pgHealthCheckTimeout": {
              "description": "PGHealthCheckTimeout is the time (in minutes) that the operator will wait for the placement groups to become\nhealthy (active+clean) after a drain was completed and OSDs came back up. Rook will continue with the next drain\nif the timeout exceeds. It only works if managePodBudgets is true.\nNo values or 0 means that the operator will wait until the placement groups are healthy before unblocking the next drain.",
              "format": "int64",
              "type": "integer"
            },
            "pgHealthyRegex": {
              "description": "PgHealthyRegex is the regular expression that is used to determine which PG states should be considered healthy.\nThe default is `^(active\\+clean|active\\+clean\\+scrubbing|active\\+clean\\+scrubbing\\+deep)$`",
              "type": "string"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "external": {
          "description": "Whether the Ceph Cluster is running external to this Kubernetes cluster\nmon, mgr, osd, mds, and discover daemons will not be created for external clusters.",
          "nullable": true,
          "properties": {
            "enable": {
              "description": "Enable determines whether external mode is enabled or not",
              "type": "boolean"
            }
          },
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true,
          "additionalProperties": false
        },
        "healthCheck": {
          "description": "Internal daemon healthchecks and liveness probe",
          "nullable": true,
          "properties": {
            "daemonHealth": {
              "description": "DaemonHealth is the health check for a given daemon",
              "nullable": true,
              "properties": {
                "mon": {
                  "description": "Monitor represents the health check settings for the Ceph monitor",
                  "nullable": true,
                  "properties": {
                    "disabled": {
                      "type": "boolean"
                    },
                    "interval": {
                      "description": "Interval is the internal in second or minute for the health check to run like 60s for 60 seconds",
                      "type": "string"
                    },
                    "timeout": {
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "osd": {
                  "description": "ObjectStorageDaemon represents the health check settings for the Ceph OSDs",
                  "nullable": true,
                  "properties": {
                    "disabled": {
                      "type": "boolean"
                    },
                    "interval": {
                      "description": "Interval is the internal in second or minute for the health check to run like 60s for 60 seconds",
                      "type": "string"
                    },
                    "timeout": {
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "status": {
                  "description": "Status represents the health check settings for the Ceph health",
                  "nullable": true,
                  "properties": {
                    "disabled": {
                      "type": "boolean"
                    },
                    "interval": {
                      "description": "Interval is the internal in second or minute for the health check to run like 60s for 60 seconds",
                      "type": "string"
                    },
                    "timeout": {
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "livenessProbe": {
              "additionalProperties": {
                "description": "ProbeSpec is a wrapper around Probe so it can be enabled or disabled for a Ceph daemon",
                "properties": {
                  "disabled": {
                    "description": "Disabled determines whether probe is disable or not",
                    "type": "boolean"
                  },
                  "probe": {
                    "description": "Probe describes a health check to be performed against a container to determine whether it is\nalive or ready to receive traffic.",
                    "properties": {
                      "exec": {
                        "description": "Exec specifies a command to execute in the container.",
                        "properties": {
                          "command": {
                            "description": "Command is the command line to execute inside the container, the working directory for the\ncommand  is root ('/') in the container's filesystem. The command is simply exec'd, it is\nnot run inside a shell, so traditional shell instructions ('|', etc) won't work. To use\na shell, you need to explicitly call out to that shell.\nExit status of 0 is treated as live/healthy and non-zero is unhealthy.",
                            "items": {
                              "type": "string"
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "failureThreshold": {
                        "description": "Minimum consecutive failures for the probe to be considered failed after having succeeded.\nDefaults to 3. Minimum value is 1.",
                        "format": "int32",
                        "type": "integer"
                      },
                      "grpc": {
                        "description": "GRPC specifies a GRPC HealthCheckRequest.",
                        "properties": {
                          "port": {
                            "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.",
                            "format": "int32",
                            "type": "integer"
                          },
                          "service": {
                            "default": "",
                            "description": "Service is the name of the service to place in the gRPC HealthCheckRequest\n(see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.",
                            "type": "string"
                          }
                        },
                        "required": [
                          "port"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "httpGet": {
                        "description": "HTTPGet specifies an HTTP GET request to perform.",
                        "properties": {
                          "host": {
                            "description": "Host name to connect to, defaults to the pod IP. You probably want to set\n\"Host\" in httpHeaders instead.",
                            "type": "string"
                          },
                          "httpHeaders": {
                            "description": "Custom headers to set in the request. HTTP allows repeated headers.",
                            "items": {
                              "description": "HTTPHeader describes a custom header to be used in HTTP probes",
                              "properties": {
                                "name": {
                                  "description": "The header field name.\nThis will be canonicalized upon output, so case-variant names will be understood as the same header.",
                                  "type": "string"
                                },
                                "value": {
                                  "description": "The header field value",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "name",
                                "value"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "path": {
                            "description": "Path to access on the HTTP server.",
                            "type": "string"
                          },
                          "port": {
                            "anyOf": [
                              {
                                "type": "integer"
                              },
                              {
                                "type": "string"
                              }
                            ],
                            "description": "Name or number of the port to access on the container.\nNumber must be in the range 1 to 65535.\nName must be an IANA_SVC_NAME.",
                            "x-kubernetes-int-or-string": true
                          },
                          "scheme": {
                            "description": "Scheme to use for connecting to the host.\nDefaults to HTTP.",
                            "type": "string"
                          }
                        },
                        "required": [
                          "port"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "initialDelaySeconds": {
                        "description": "Number of seconds after the container has started before liveness probes are initiated.\nMore info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes",
                        "format": "int32",
                        "type": "integer"
                      },
                      "periodSeconds": {
                        "description": "How often (in seconds) to perform the probe.\nDefault to 10 seconds. Minimum value is 1.",
                        "format": "int32",
                        "type": "integer"
                      },
                      "successThreshold": {
                        "description": "Minimum consecutive successes for the probe to be considered successful after having failed.\nDefaults to 1. Must be 1 for liveness and startup. Minimum value is 1.",
                        "format": "int32",
                        "type": "integer"
                      },
                      "tcpSocket": {
                        "description": "TCPSocket specifies a connection to a TCP port.",
                        "properties": {
                          "host": {
                            "description": "Optional: Host name to connect to, defaults to the pod IP.",
                            "type": "string"
                          },
                          "port": {
                            "anyOf": [
                              {
                                "type": "integer"
                              },
                              {
                                "type": "string"
                              }
                            ],
                            "description": "Number or name of the port to access on the container.\nNumber must be in the range 1 to 65535.\nName must be an IANA_SVC_NAME.",
                            "x-kubernetes-int-or-string": true
                          }
                        },
                        "required": [
                          "port"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "terminationGracePeriodSeconds": {
                        "format": "int64",
                        "type": "integer"
                      },
                      "timeoutSeconds": {
                        "description": "Number of seconds after which the probe times out.\nDefaults to 1 second. Minimum value is 1.\nMore info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes",
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "type": "object",
                    "additionalProperties": false
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "description": "LivenessProbe allows changing the livenessProbe configuration for a given daemon",
              "type": "object"
            },
            "startupProbe": {
              "additionalProperties": {
                "description": "ProbeSpec is a wrapper around Probe so it can be enabled or disabled for a Ceph daemon",
                "properties": {
                  "disabled": {
                    "description": "Disabled determines whether probe is disable or not",
                    "type": "boolean"
                  },
                  "probe": {
                    "description": "Probe describes a health check to be performed against a container to determine whether it is\nalive or ready to receive traffic.",
                    "properties": {
                      "exec": {
                        "description": "Exec specifies a command to execute in the container.",
                        "properties": {
                          "command": {
                            "description": "Command is the command line to execute inside the container, the working directory for the\ncommand  is root ('/') in the container's filesystem. The command is simply exec'd, it is\nnot run inside a shell, so traditional shell instructions ('|', etc) won't work. To use\na shell, you need to explicitly call out to that shell.\nExit status of 0 is treated as live/healthy and non-zero is unhealthy.",
                            "items": {
                              "type": "string"
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "failureThreshold": {
                        "description": "Minimum consecutive failures for the probe to be considered failed after having succeeded.\nDefaults to 3. Minimum value is 1.",
                        "format": "int32",
                        "type": "integer"
                      },
                      "grpc": {
                        "description": "GRPC specifies a GRPC HealthCheckRequest.",
                        "properties": {
                          "port": {
                            "description": "Port number of the gRPC service. Number must be in the range 1 to 65535.",
                            "format": "int32",
                            "type": "integer"
                          },
                          "service": {
                            "default": "",
                            "description": "Service is the name of the service to place in the gRPC HealthCheckRequest\n(see https://github.com/grpc/grpc/blob/master/doc/health-checking.md).\n\nIf this is not specified, the default behavior is defined by gRPC.",
                            "type": "string"
                          }
                        },
                        "required": [
                          "port"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "httpGet": {
                        "description": "HTTPGet specifies an HTTP GET request to perform.",
                        "properties": {
                          "host": {
                            "description": "Host name to connect to, defaults to the pod IP. You probably want to set\n\"Host\" in httpHeaders instead.",
                            "type": "string"
                          },
                          "httpHeaders": {
                            "description": "Custom headers to set in the request. HTTP allows repeated headers.",
                            "items": {
                              "description": "HTTPHeader describes a custom header to be used in HTTP probes",
                              "properties": {
                                "name": {
                                  "description": "The header field name.\nThis will be canonicalized upon output, so case-variant names will be understood as the same header.",
                                  "type": "string"
                                },
                                "value": {
                                  "description": "The header field value",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "name",
                                "value"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "path": {
                            "description": "Path to access on the HTTP server.",
                            "type": "string"
                          },
                          "port": {
                            "anyOf": [
                              {
                                "type": "integer"
                              },
                              {
                                "type": "string"
                              }
                            ],
                            "description": "Name or number of the port to access on the container.\nNumber must be in the range 1 to 65535.\nName must be an IANA_SVC_NAME.",
                            "x-kubernetes-int-or-string": true
                          },
                          "scheme": {
                            "description": "Scheme to use for connecting to the host.\nDefaults to HTTP.",
                            "type": "string"
                          }
                        },
                        "required": [
                          "port"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "initialDelaySeconds": {
                        "description": "Number of seconds after the container has started before liveness probes are initiated.\nMore info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes",
                        "format": "int32",
                        "type": "integer"
                      },
                      "periodSeconds": {
                        "description": "How often (in seconds) to perform the probe.\nDefault to 10 seconds. Minimum value is 1.",
                        "format": "int32",
                        "type": "integer"
                      },
                      "successThreshold": {
                        "description": "Minimum consecutive successes for the probe to be considered successful after having failed.\nDefaults to 1. Must be 1 for liveness and startup. Minimum value is 1.",
                        "format": "int32",
                        "type": "integer"
                      },
                      "tcpSocket": {
                        "description": "TCPSocket specifies a connection to a TCP port.",
                        "properties": {
                          "host": {
                            "description": "Optional: Host name to connect to, defaults to the pod IP.",
                            "type": "string"
                          },
                          "port": {
                            "anyOf": [
                              {
                                "type": "integer"
                              },
                              {
                                "type": "string"
                              }
                            ],
                            "description": "Number or name of the port to access on the container.\nNumber must be in the range 1 to 65535.\nName must be an IANA_SVC_NAME.",
                            "x-kubernetes-int-or-string": true
                          }
                        },
                        "required": [
                          "port"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "terminationGracePeriodSeconds": {
                        "format": "int64",
                        "type": "integer"
                      },
                      "timeoutSeconds": {
                        "description": "Number of seconds after which the probe times out.\nDefaults to 1 second. Minimum value is 1.\nMore info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes",
                        "format": "int32",
                        "type": "integer"
                      }
                    },
                    "type": "object",
                    "additionalProperties": false
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "description": "StartupProbe allows changing the startupProbe configuration for a given daemon",
              "type": "object"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "labels": {
          "additionalProperties": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Labels are label for a given daemons",
            "type": "object"
          },
          "description": "The labels-related configuration to add/set on each Pod related object.",
          "nullable": true,
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "logCollector": {
          "description": "Logging represents loggings settings",
          "nullable": true,
          "properties": {
            "enabled": {
              "description": "Enabled represents whether the log collector is enabled",
              "type": "boolean"
            },
            "maxLogSize": {
              "anyOf": [
                {
                  "type": "integer"
                },
                {
                  "type": "string"
                }
              ],
              "description": "MaxLogSize is the maximum size of the log per ceph daemons. Must be at least 1M.",
              "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
              "x-kubernetes-int-or-string": true
            },
            "periodicity": {
              "description": "Periodicity is the periodicity of the log rotation.",
              "pattern": "^$|^(hourly|daily|weekly|monthly|1h|24h|1d)$",
              "type": "string"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "mgr": {
          "description": "A spec for mgr related options",
          "nullable": true,
          "properties": {
            "allowMultiplePerNode": {
              "description": "AllowMultiplePerNode allows to run multiple managers on the same node (not recommended)",
              "type": "boolean"
            },
            "count": {
              "description": "Count is the number of manager daemons to run",
              "maximum": 5,
              "minimum": 0,
              "type": "integer"
            },
            "modules": {
              "description": "Modules is the list of ceph manager modules to enable/disable",
              "items": {
                "description": "Module represents mgr modules that the user wants to enable or disable",
                "properties": {
                  "enabled": {
                    "description": "Enabled determines whether a module should be enabled or not",
                    "type": "boolean"
                  },
                  "name": {
                    "description": "Name is the name of the ceph manager module",
                    "type": "string"
                  },
                  "settings": {
                    "description": "Settings to further configure the module",
                    "properties": {
                      "balancerMode": {
                        "description": "BalancerMode sets the `balancer` module with different modes like `upmap`, `crush-compact` etc",
                        "enum": [
                          "",
                          "crush-compat",
                          "upmap",
                          "read",
                          "upmap-read"
                        ],
                        "type": "string"
                      }
                    },
                    "type": "object",
                    "additionalProperties": false
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "nullable": true,
              "type": "array"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "mon": {
          "description": "A spec for mon related options",
          "nullable": true,
          "properties": {
            "allowMultiplePerNode": {
              "description": "AllowMultiplePerNode determines if we can run multiple monitors on the same node (not recommended)",
              "type": "boolean"
            },
            "count": {
              "description": "Count is the number of Ceph monitors",
              "maximum": 9,
              "minimum": 0,
              "type": "integer"
            },
            "failureDomainLabel": {
              "type": "string"
            },
            "stretchCluster": {
              "description": "StretchCluster is the stretch cluster specification",
              "properties": {
                "failureDomainLabel": {
                  "description": "FailureDomainLabel the failure domain name (e,g: zone)",
                  "type": "string"
                },
                "subFailureDomain": {
                  "description": "SubFailureDomain is the failure domain within a zone",
                  "type": "string"
                },
                "zones": {
                  "description": "Zones is the list of zones",
                  "items": {
                    "description": "MonZoneSpec represents the specification of a zone in a Ceph Cluster",
                    "properties": {
                      "arbiter": {
                        "description": "Arbiter determines if the zone contains the arbiter used for stretch cluster mode",
                        "type": "boolean"
                      },
                      "name": {
                        "description": "Name is the name of the zone",
                        "type": "string"
                      },
                      "volumeClaimTemplate": {
                        "description": "VolumeClaimTemplate is the PVC template",
                        "properties": {
                          "metadata": {
                            "description": "Standard object's metadata.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
                            "properties": {
                              "annotations": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              },
                              "finalizers": {
                                "items": {
                                  "type": "string"
                                },
                                "type": "array"
                              },
                              "labels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "type": "object"
                              },
                              "name": {
                                "type": "string"
                              },
                              "namespace": {
                                "type": "string"
                              }
                            },
                            "type": "object",
                            "additionalProperties": false
                          },
                          "spec": {
                            "description": "spec defines the desired characteristics of a volume requested by a pod author.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims",
                            "properties": {
                              "accessModes": {
                                "description": "accessModes contains the desired access modes the volume should have.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1",
                                "items": {
                                  "type": "string"
                                },
                                "type": "array",
                                "x-kubernetes-list-type": "atomic"
                              },
                              "dataSource": {
                                "description": "dataSource field can be used to specify either:\n* An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)\n* An existing PVC (PersistentVolumeClaim)\nIf the provisioner or an external controller can support the specified data source,\nit will create a new volume based on the contents of the specified data source.\nWhen the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef,\nand dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified.\nIf the namespace is specified, then dataSourceRef will not be copied to dataSource.",
                                "properties": {
                                  "apiGroup": {
                                    "description": "APIGroup is the group for the resource being referenced.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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",
                                "additionalProperties": false
                              },
                              "dataSourceRef": {
                                "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty\nvolume is desired. This may be any object from a non-empty API group (non\ncore object) or a PersistentVolumeClaim object.\nWhen this field is specified, volume binding will only succeed if the type of\nthe specified object matches some installed volume populator or dynamic\nprovisioner.\nThis field will replace the functionality of the dataSource field and as such\nif both fields are non-empty, they must have the same value. For backwards\ncompatibility, when namespace isn't specified in dataSourceRef,\nboth fields (dataSource and dataSourceRef) will be set to the same\nvalue automatically if one of them is empty and the other is non-empty.\nWhen namespace is specified in dataSourceRef,\ndataSource isn't set to the same value and must be empty.\nThere are three important differences between dataSource and dataSourceRef:\n* While dataSource only allows two specific types of objects, dataSourceRef\n  allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n  preserves all values, and generates an error if a disallowed value is\n  specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n  in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.\n(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.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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\nNote 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.\n(Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "kind",
                                  "name"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "resources": {
                                "description": "resources represents the minimum resources the volume should have.\nIf RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements\nthat are lower than previous value but must still be higher than capacity recorded in the\nstatus field of the claim.\nMore 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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                                    "type": "object"
                                  }
                                },
                                "type": "object",
                                "additionalProperties": false
                              },
                              "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\nrelates 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.\nValid 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,\nthe values array must be non-empty. If the operator is Exists or DoesNotExist,\nthe values array must be empty. This array is replaced during a strategic\nmerge patch.",
                                          "items": {
                                            "type": "string"
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        }
                                      },
                                      "required": [
                                        "key",
                                        "operator"
                                      ],
                                      "type": "object",
                                      "additionalProperties": false
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  },
                                  "matchLabels": {
                                    "additionalProperties": {
                                      "type": "string"
                                    },
                                    "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels\nmap is equivalent to an element of matchExpressions, whose key field is \"key\", the\noperator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                                    "type": "object"
                                  }
                                },
                                "type": "object",
                                "x-kubernetes-map-type": "atomic",
                                "additionalProperties": false
                              },
                              "storageClassName": {
                                "description": "storageClassName is the name of the StorageClass required by the claim.\nMore 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.\nIf specified, the CSI driver will create or update the volume with the attributes defined\nin the corresponding VolumeAttributesClass. This has a different purpose than storageClassName,\nit can be changed after the claim is created. An empty string value means that no VolumeAttributesClass\nwill be applied to the claim but it's not allowed to reset this field to empty string once it is set.\nIf unspecified and the PersistentVolumeClaim is unbound, the default VolumeAttributesClass\nwill be set by the persistentvolume controller if it exists.\nIf the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be\nset to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource\nexists.\nMore info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\n(Beta) Using this field requires the VolumeAttributesClass feature gate to be enabled (off by default).",
                                "type": "string"
                              },
                              "volumeMode": {
                                "description": "volumeMode defines what type of volume is required by the claim.\nValue 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",
                            "additionalProperties": false
                          }
                        },
                        "type": "object",
                        "x-kubernetes-preserve-unknown-fields": true,
                        "additionalProperties": false
                      }
                    },
                    "type": "object",
                    "additionalProperties": false
                  },
                  "nullable": true,
                  "type": "array"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "volumeClaimTemplate": {
              "description": "VolumeClaimTemplate is the PVC definition",
              "properties": {
                "metadata": {
                  "description": "Standard object's metadata.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
                  "properties": {
                    "annotations": {
                      "additionalProperties": {
                        "type": "string"
                      },
                      "type": "object"
                    },
                    "finalizers": {
                      "items": {
                        "type": "string"
                      },
                      "type": "array"
                    },
                    "labels": {
                      "additionalProperties": {
                        "type": "string"
                      },
                      "type": "object"
                    },
                    "name": {
                      "type": "string"
                    },
                    "namespace": {
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "spec": {
                  "description": "spec defines the desired characteristics of a volume requested by a pod author.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims",
                  "properties": {
                    "accessModes": {
                      "description": "accessModes contains the desired access modes the volume should have.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1",
                      "items": {
                        "type": "string"
                      },
                      "type": "array",
                      "x-kubernetes-list-type": "atomic"
                    },
                    "dataSource": {
                      "description": "dataSource field can be used to specify either:\n* An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)\n* An existing PVC (PersistentVolumeClaim)\nIf the provisioner or an external controller can support the specified data source,\nit will create a new volume based on the contents of the specified data source.\nWhen the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef,\nand dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified.\nIf the namespace is specified, then dataSourceRef will not be copied to dataSource.",
                      "properties": {
                        "apiGroup": {
                          "description": "APIGroup is the group for the resource being referenced.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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",
                      "additionalProperties": false
                    },
                    "dataSourceRef": {
                      "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty\nvolume is desired. This may be any object from a non-empty API group (non\ncore object) or a PersistentVolumeClaim object.\nWhen this field is specified, volume binding will only succeed if the type of\nthe specified object matches some installed volume populator or dynamic\nprovisioner.\nThis field will replace the functionality of the dataSource field and as such\nif both fields are non-empty, they must have the same value. For backwards\ncompatibility, when namespace isn't specified in dataSourceRef,\nboth fields (dataSource and dataSourceRef) will be set to the same\nvalue automatically if one of them is empty and the other is non-empty.\nWhen namespace is specified in dataSourceRef,\ndataSource isn't set to the same value and must be empty.\nThere are three important differences between dataSource and dataSourceRef:\n* While dataSource only allows two specific types of objects, dataSourceRef\n  allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n  preserves all values, and generates an error if a disallowed value is\n  specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n  in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.\n(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.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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\nNote 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.\n(Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.",
                          "type": "string"
                        }
                      },
                      "required": [
                        "kind",
                        "name"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "resources": {
                      "description": "resources represents the minimum resources the volume should have.\nIf RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements\nthat are lower than previous value but must still be higher than capacity recorded in the\nstatus field of the claim.\nMore 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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                          "type": "object"
                        }
                      },
                      "type": "object",
                      "additionalProperties": false
                    },
                    "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\nrelates 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.\nValid 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,\nthe values array must be non-empty. If the operator is Exists or DoesNotExist,\nthe values array must be empty. This array is replaced during a strategic\nmerge patch.",
                                "items": {
                                  "type": "string"
                                },
                                "type": "array",
                                "x-kubernetes-list-type": "atomic"
                              }
                            },
                            "required": [
                              "key",
                              "operator"
                            ],
                            "type": "object",
                            "additionalProperties": false
                          },
                          "type": "array",
                          "x-kubernetes-list-type": "atomic"
                        },
                        "matchLabels": {
                          "additionalProperties": {
                            "type": "string"
                          },
                          "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels\nmap is equivalent to an element of matchExpressions, whose key field is \"key\", the\noperator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                          "type": "object"
                        }
                      },
                      "type": "object",
                      "x-kubernetes-map-type": "atomic",
                      "additionalProperties": false
                    },
                    "storageClassName": {
                      "description": "storageClassName is the name of the StorageClass required by the claim.\nMore 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.\nIf specified, the CSI driver will create or update the volume with the attributes defined\nin the corresponding VolumeAttributesClass. This has a different purpose than storageClassName,\nit can be changed after the claim is created. An empty string value means that no VolumeAttributesClass\nwill be applied to the claim but it's not allowed to reset this field to empty string once it is set.\nIf unspecified and the PersistentVolumeClaim is unbound, the default VolumeAttributesClass\nwill be set by the persistentvolume controller if it exists.\nIf the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be\nset to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource\nexists.\nMore info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\n(Beta) Using this field requires the VolumeAttributesClass feature gate to be enabled (off by default).",
                      "type": "string"
                    },
                    "volumeMode": {
                      "description": "volumeMode defines what type of volume is required by the claim.\nValue 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",
                  "additionalProperties": false
                }
              },
              "type": "object",
              "x-kubernetes-preserve-unknown-fields": true,
              "additionalProperties": false
            },
            "zones": {
              "description": "Zones are specified when we want to provide zonal awareness to mons",
              "items": {
                "description": "MonZoneSpec represents the specification of a zone in a Ceph Cluster",
                "properties": {
                  "arbiter": {
                    "description": "Arbiter determines if the zone contains the arbiter used for stretch cluster mode",
                    "type": "boolean"
                  },
                  "name": {
                    "description": "Name is the name of the zone",
                    "type": "string"
                  },
                  "volumeClaimTemplate": {
                    "description": "VolumeClaimTemplate is the PVC template",
                    "properties": {
                      "metadata": {
                        "description": "Standard object's metadata.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
                        "properties": {
                          "annotations": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          },
                          "finalizers": {
                            "items": {
                              "type": "string"
                            },
                            "type": "array"
                          },
                          "labels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "type": "object"
                          },
                          "name": {
                            "type": "string"
                          },
                          "namespace": {
                            "type": "string"
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "spec": {
                        "description": "spec defines the desired characteristics of a volume requested by a pod author.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims",
                        "properties": {
                          "accessModes": {
                            "description": "accessModes contains the desired access modes the volume should have.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1",
                            "items": {
                              "type": "string"
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "dataSource": {
                            "description": "dataSource field can be used to specify either:\n* An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)\n* An existing PVC (PersistentVolumeClaim)\nIf the provisioner or an external controller can support the specified data source,\nit will create a new volume based on the contents of the specified data source.\nWhen the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef,\nand dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified.\nIf the namespace is specified, then dataSourceRef will not be copied to dataSource.",
                            "properties": {
                              "apiGroup": {
                                "description": "APIGroup is the group for the resource being referenced.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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",
                            "additionalProperties": false
                          },
                          "dataSourceRef": {
                            "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty\nvolume is desired. This may be any object from a non-empty API group (non\ncore object) or a PersistentVolumeClaim object.\nWhen this field is specified, volume binding will only succeed if the type of\nthe specified object matches some installed volume populator or dynamic\nprovisioner.\nThis field will replace the functionality of the dataSource field and as such\nif both fields are non-empty, they must have the same value. For backwards\ncompatibility, when namespace isn't specified in dataSourceRef,\nboth fields (dataSource and dataSourceRef) will be set to the same\nvalue automatically if one of them is empty and the other is non-empty.\nWhen namespace is specified in dataSourceRef,\ndataSource isn't set to the same value and must be empty.\nThere are three important differences between dataSource and dataSourceRef:\n* While dataSource only allows two specific types of objects, dataSourceRef\n  allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n  preserves all values, and generates an error if a disallowed value is\n  specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n  in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.\n(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.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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\nNote 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.\n(Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.",
                                "type": "string"
                              }
                            },
                            "required": [
                              "kind",
                              "name"
                            ],
                            "type": "object",
                            "additionalProperties": false
                          },
                          "resources": {
                            "description": "resources represents the minimum resources the volume should have.\nIf RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements\nthat are lower than previous value but must still be higher than capacity recorded in the\nstatus field of the claim.\nMore 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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "additionalProperties": false
                          },
                          "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\nrelates 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.\nValid 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,\nthe values array must be non-empty. If the operator is Exists or DoesNotExist,\nthe values array must be empty. This array is replaced during a strategic\nmerge patch.",
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    }
                                  },
                                  "required": [
                                    "key",
                                    "operator"
                                  ],
                                  "type": "object",
                                  "additionalProperties": false
                                },
                                "type": "array",
                                "x-kubernetes-list-type": "atomic"
                              },
                              "matchLabels": {
                                "additionalProperties": {
                                  "type": "string"
                                },
                                "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels\nmap is equivalent to an element of matchExpressions, whose key field is \"key\", the\noperator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                                "type": "object"
                              }
                            },
                            "type": "object",
                            "x-kubernetes-map-type": "atomic",
                            "additionalProperties": false
                          },
                          "storageClassName": {
                            "description": "storageClassName is the name of the StorageClass required by the claim.\nMore 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.\nIf specified, the CSI driver will create or update the volume with the attributes defined\nin the corresponding VolumeAttributesClass. This has a different purpose than storageClassName,\nit can be changed after the claim is created. An empty string value means that no VolumeAttributesClass\nwill be applied to the claim but it's not allowed to reset this field to empty string once it is set.\nIf unspecified and the PersistentVolumeClaim is unbound, the default VolumeAttributesClass\nwill be set by the persistentvolume controller if it exists.\nIf the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be\nset to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource\nexists.\nMore info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\n(Beta) Using this field requires the VolumeAttributesClass feature gate to be enabled (off by default).",
                            "type": "string"
                          },
                          "volumeMode": {
                            "description": "volumeMode defines what type of volume is required by the claim.\nValue 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",
                        "additionalProperties": false
                      }
                    },
                    "type": "object",
                    "x-kubernetes-preserve-unknown-fields": true,
                    "additionalProperties": false
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "type": "array"
            }
          },
          "type": "object",
          "x-kubernetes-validations": [
            {
              "message": "zones must be less than or equal to count",
              "rule": "!has(self.zones) || (has(self.zones) && (size(self.zones) <= self.count))"
            },
            {
              "message": "stretchCluster zones must be equal to 3",
              "rule": "!has(self.stretchCluster) || (has(self.stretchCluster) && (size(self.stretchCluster.zones) > 0) && (size(self.stretchCluster.zones) == 3))"
            }
          ],
          "additionalProperties": false
        },
        "monitoring": {
          "description": "Prometheus based Monitoring settings",
          "nullable": true,
          "properties": {
            "enabled": {
              "description": "Enabled determines whether to create the prometheus rules for the ceph cluster. If true, the prometheus\ntypes must exist or the creation will fail. Default is false.",
              "type": "boolean"
            },
            "exporter": {
              "description": "Ceph exporter configuration",
              "properties": {
                "perfCountersPrioLimit": {
                  "default": 5,
                  "description": "Only performance counters greater than or equal to this option are fetched",
                  "format": "int64",
                  "type": "integer"
                },
                "statsPeriodSeconds": {
                  "default": 5,
                  "description": "Time to wait before sending requests again to exporter server (seconds)",
                  "format": "int64",
                  "type": "integer"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "externalMgrEndpoints": {
              "description": "ExternalMgrEndpoints points to an existing Ceph prometheus exporter endpoint",
              "items": {
                "description": "EndpointAddress is a tuple that describes single IP address.",
                "properties": {
                  "hostname": {
                    "description": "The Hostname of this endpoint",
                    "type": "string"
                  },
                  "ip": {
                    "description": "The IP of this endpoint.\nMay not be loopback (127.0.0.0/8 or ::1), link-local (169.254.0.0/16 or fe80::/10),\nor link-local multicast (224.0.0.0/24 or ff02::/16).",
                    "type": "string"
                  },
                  "nodeName": {
                    "description": "Optional: Node hosting this endpoint. This can be used to determine endpoints local to a node.",
                    "type": "string"
                  },
                  "targetRef": {
                    "description": "Reference to object providing the endpoint.",
                    "properties": {
                      "apiVersion": {
                        "description": "API version of the referent.",
                        "type": "string"
                      },
                      "fieldPath": {
                        "description": "If referring to a piece of an object instead of an entire object, this string\nshould contain a valid JSON/Go field access statement, such as desiredState.manifest.containers[2].\nFor example, if the object reference is to a container within a pod, this would take on a value like:\n\"spec.containers{name}\" (where \"name\" refers to the name of the container that triggered\nthe event) or if no container name is specified \"spec.containers[2]\" (container with\nindex 2 in this pod). This syntax is chosen only to have some well-defined way of\nreferencing a part of an object.",
                        "type": "string"
                      },
                      "kind": {
                        "description": "Kind of the referent.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
                        "type": "string"
                      },
                      "name": {
                        "description": "Name of the referent.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names",
                        "type": "string"
                      },
                      "namespace": {
                        "description": "Namespace of the referent.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/",
                        "type": "string"
                      },
                      "resourceVersion": {
                        "description": "Specific resourceVersion to which this reference is made, if any.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency",
                        "type": "string"
                      },
                      "uid": {
                        "description": "UID of the referent.\nMore info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids",
                        "type": "string"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-map-type": "atomic",
                    "additionalProperties": false
                  }
                },
                "required": [
                  "ip"
                ],
                "type": "object",
                "x-kubernetes-map-type": "atomic",
                "additionalProperties": false
              },
              "nullable": true,
              "type": "array"
            },
            "externalMgrPrometheusPort": {
              "description": "ExternalMgrPrometheusPort Prometheus exporter port",
              "maximum": 65535,
              "minimum": 0,
              "type": "integer"
            },
            "interval": {
              "description": "Interval determines prometheus scrape interval",
              "type": "string"
            },
            "metricsDisabled": {
              "description": "Whether to disable the metrics reported by Ceph. If false, the prometheus mgr module and Ceph exporter are enabled.\nIf true, the prometheus mgr module and Ceph exporter are both disabled. Default is false.",
              "type": "boolean"
            },
            "port": {
              "description": "Port is the prometheus server port",
              "maximum": 65535,
              "minimum": 0,
              "type": "integer"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "network": {
          "description": "Network related configuration",
          "nullable": true,
          "properties": {
            "addressRanges": {
              "description": "AddressRanges specify a list of CIDRs that Rook will apply to Ceph's 'public_network' and/or\n'cluster_network' configurations. This config section may be used for the \"host\" or \"multus\"\nnetwork providers.",
              "nullable": true,
              "properties": {
                "cluster": {
                  "description": "Cluster defines a list of CIDRs to use for Ceph cluster network communication.",
                  "items": {
                    "description": "An IPv4 or IPv6 network CIDR.\n\nThis naive kubebuilder regex provides immediate feedback for some typos and for a common problem\ncase where the range spec is forgotten (e.g., /24). Rook does in-depth validation in code.",
                    "pattern": "^[0-9a-fA-F:.]{2,}\\/[0-9]{1,3}$",
                    "type": "string"
                  },
                  "type": "array"
                },
                "public": {
                  "description": "Public defines a list of CIDRs to use for Ceph public network communication.",
                  "items": {
                    "description": "An IPv4 or IPv6 network CIDR.\n\nThis naive kubebuilder regex provides immediate feedback for some typos and for a common problem\ncase where the range spec is forgotten (e.g., /24). Rook does in-depth validation in code.",
                    "pattern": "^[0-9a-fA-F:.]{2,}\\/[0-9]{1,3}$",
                    "type": "string"
                  },
                  "type": "array"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "connections": {
              "description": "Settings for network connections such as compression and encryption across the\nwire.",
              "nullable": true,
              "properties": {
                "compression": {
                  "description": "Compression settings for the network connections.",
                  "nullable": true,
                  "properties": {
                    "enabled": {
                      "description": "Whether to compress the data in transit across the wire.\nThe default is not set.",
                      "type": "boolean"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "encryption": {
                  "description": "Encryption settings for the network connections.",
                  "nullable": true,
                  "properties": {
                    "enabled": {
                      "description": "Whether to encrypt the data in transit across the wire to prevent eavesdropping\nthe data on the network. The default is not set. Even if encryption is not enabled,\nclients still establish a strong initial authentication for the connection\nand data integrity is still validated with a crc check. When encryption is enabled,\nall communication between clients and Ceph daemons, or between Ceph daemons will\nbe encrypted.",
                      "type": "boolean"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "requireMsgr2": {
                  "description": "Whether to require msgr2 (port 3300) even if compression or encryption are not enabled.\nIf true, the msgr1 port (6789) will be disabled.\nRequires a kernel that supports msgr2 (kernel 5.11 or CentOS 8.4 or newer).",
                  "type": "boolean"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "dualStack": {
              "description": "DualStack determines whether Ceph daemons should listen on both IPv4 and IPv6",
              "type": "boolean"
            },
            "hostNetwork": {
              "description": "HostNetwork to enable host network.\nIf host networking is enabled or disabled on a running cluster, then the operator will automatically fail over all the mons to\napply the new network settings.",
              "type": "boolean"
            },
            "ipFamily": {
              "description": "IPFamily is the single stack IPv6 or IPv4 protocol",
              "enum": [
                "IPv4",
                "IPv6"
              ],
              "nullable": true,
              "type": "string"
            },
            "multiClusterService": {
              "description": "Enable multiClusterService to export the Services between peer clusters",
              "properties": {
                "clusterID": {
                  "description": "ClusterID uniquely identifies a cluster. It is used as a prefix to nslookup exported\nservices. For example: <clusterid>.<svc>.<ns>.svc.clusterset.local",
                  "type": "string"
                },
                "enabled": {
                  "description": "Enable multiClusterService to export the mon and OSD services to peer cluster.\nEnsure that peer clusters are connected using an MCS API compatible application,\nlike Globalnet Submariner.",
                  "type": "boolean"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "provider": {
              "description": "Provider is what provides network connectivity to the cluster e.g. \"host\" or \"multus\".\nIf the Provider is updated from being empty to \"host\" on a running cluster, then the operator will automatically fail over all the mons to apply the \"host\" network settings.",
              "enum": [
                "",
                "host",
                "multus"
              ],
              "nullable": true,
              "type": "string",
              "x-kubernetes-validations": [
                {
                  "message": "network provider must be disabled (reverted to empty string) before a new provider is enabled",
                  "rule": "self == '' || self == oldSelf"
                }
              ]
            },
            "selectors": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "Selectors define NetworkAttachmentDefinitions to be used for Ceph public and/or cluster\nnetworks when the \"multus\" network provider is used. This config section is not used for\nother network providers.\n\nValid keys are \"public\" and \"cluster\". Refer to Ceph networking documentation for more:\nhttps://docs.ceph.com/en/latest/rados/configuration/network-config-ref/\n\nRefer to Multus network annotation documentation for help selecting values:\nhttps://github.com/k8snetworkplumbingwg/multus-cni/blob/master/docs/how-to-use.md#run-pod-with-network-annotation\n\nRook will make a best-effort attempt to automatically detect CIDR address ranges for given\nnetwork attachment definitions. Rook's methods are robust but may be imprecise for\nsufficiently complicated networks. Rook's auto-detection process obtains a new IP address\nlease for each CephCluster reconcile. If Rook fails to detect, incorrectly detects, only\npartially detects, or if underlying networks do not support reusing old IP addresses, it is\nbest to use the 'addressRanges' config section to specify CIDR ranges for the Ceph cluster.\n\nAs a contrived example, one can use a theoretical Kubernetes-wide network for Ceph client\ntraffic and a theoretical Rook-only network for Ceph replication traffic as shown:\n  selectors:\n    public: \"default/cluster-fast-net\"\n    cluster: \"rook-ceph/ceph-backend-net\"",
              "nullable": true,
              "type": "object"
            }
          },
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true,
          "x-kubernetes-validations": [
            {
              "message": "at least one network selector must be specified when using multus",
              "rule": "!has(self.provider) || (self.provider != 'multus' || (self.provider == 'multus' && size(self.selectors) > 0))"
            },
            {
              "message": "the legacy hostNetwork setting can only be set if the network.provider is set to the empty string",
              "rule": "!has(self.hostNetwork) || self.hostNetwork == false || !has(self.provider) || self.provider == \"\""
            }
          ],
          "additionalProperties": false
        },
        "placement": {
          "additionalProperties": {
            "properties": {
              "nodeAffinity": {
                "properties": {
                  "preferredDuringSchedulingIgnoredDuringExecution": {
                    "items": {
                      "properties": {
                        "preference": {
                          "properties": {
                            "matchExpressions": {
                              "items": {
                                "properties": {
                                  "key": {
                                    "type": "string"
                                  },
                                  "operator": {
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  }
                                },
                                "required": [
                                  "key",
                                  "operator"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "matchFields": {
                              "items": {
                                "properties": {
                                  "key": {
                                    "type": "string"
                                  },
                                  "operator": {
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  }
                                },
                                "required": [
                                  "key",
                                  "operator"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            }
                          },
                          "type": "object",
                          "x-kubernetes-map-type": "atomic",
                          "additionalProperties": false
                        },
                        "weight": {
                          "format": "int32",
                          "type": "integer"
                        }
                      },
                      "required": [
                        "preference",
                        "weight"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "requiredDuringSchedulingIgnoredDuringExecution": {
                    "properties": {
                      "nodeSelectorTerms": {
                        "items": {
                          "properties": {
                            "matchExpressions": {
                              "items": {
                                "properties": {
                                  "key": {
                                    "type": "string"
                                  },
                                  "operator": {
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  }
                                },
                                "required": [
                                  "key",
                                  "operator"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "matchFields": {
                              "items": {
                                "properties": {
                                  "key": {
                                    "type": "string"
                                  },
                                  "operator": {
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  }
                                },
                                "required": [
                                  "key",
                                  "operator"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            }
                          },
                          "type": "object",
                          "x-kubernetes-map-type": "atomic",
                          "additionalProperties": false
                        },
                        "type": "array",
                        "x-kubernetes-list-type": "atomic"
                      }
                    },
                    "required": [
                      "nodeSelectorTerms"
                    ],
                    "type": "object",
                    "x-kubernetes-map-type": "atomic",
                    "additionalProperties": false
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "podAffinity": {
                "properties": {
                  "preferredDuringSchedulingIgnoredDuringExecution": {
                    "items": {
                      "properties": {
                        "podAffinityTerm": {
                          "properties": {
                            "labelSelector": {
                              "properties": {
                                "matchExpressions": {
                                  "items": {
                                    "properties": {
                                      "key": {
                                        "type": "string"
                                      },
                                      "operator": {
                                        "type": "string"
                                      },
                                      "values": {
                                        "items": {
                                          "type": "string"
                                        },
                                        "type": "array",
                                        "x-kubernetes-list-type": "atomic"
                                      }
                                    },
                                    "required": [
                                      "key",
                                      "operator"
                                    ],
                                    "type": "object",
                                    "additionalProperties": false
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "matchLabels": {
                                  "additionalProperties": {
                                    "type": "string"
                                  },
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "x-kubernetes-map-type": "atomic",
                              "additionalProperties": false
                            },
                            "matchLabelKeys": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "mismatchLabelKeys": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "namespaceSelector": {
                              "properties": {
                                "matchExpressions": {
                                  "items": {
                                    "properties": {
                                      "key": {
                                        "type": "string"
                                      },
                                      "operator": {
                                        "type": "string"
                                      },
                                      "values": {
                                        "items": {
                                          "type": "string"
                                        },
                                        "type": "array",
                                        "x-kubernetes-list-type": "atomic"
                                      }
                                    },
                                    "required": [
                                      "key",
                                      "operator"
                                    ],
                                    "type": "object",
                                    "additionalProperties": false
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "matchLabels": {
                                  "additionalProperties": {
                                    "type": "string"
                                  },
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "x-kubernetes-map-type": "atomic",
                              "additionalProperties": false
                            },
                            "namespaces": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "topologyKey": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "topologyKey"
                          ],
                          "type": "object",
                          "additionalProperties": false
                        },
                        "weight": {
                          "format": "int32",
                          "type": "integer"
                        }
                      },
                      "required": [
                        "podAffinityTerm",
                        "weight"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "requiredDuringSchedulingIgnoredDuringExecution": {
                    "items": {
                      "properties": {
                        "labelSelector": {
                          "properties": {
                            "matchExpressions": {
                              "items": {
                                "properties": {
                                  "key": {
                                    "type": "string"
                                  },
                                  "operator": {
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  }
                                },
                                "required": [
                                  "key",
                                  "operator"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "matchLabels": {
                              "additionalProperties": {
                                "type": "string"
                              },
                              "type": "object"
                            }
                          },
                          "type": "object",
                          "x-kubernetes-map-type": "atomic",
                          "additionalProperties": false
                        },
                        "matchLabelKeys": {
                          "items": {
                            "type": "string"
                          },
                          "type": "array",
                          "x-kubernetes-list-type": "atomic"
                        },
                        "mismatchLabelKeys": {
                          "items": {
                            "type": "string"
                          },
                          "type": "array",
                          "x-kubernetes-list-type": "atomic"
                        },
                        "namespaceSelector": {
                          "properties": {
                            "matchExpressions": {
                              "items": {
                                "properties": {
                                  "key": {
                                    "type": "string"
                                  },
                                  "operator": {
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  }
                                },
                                "required": [
                                  "key",
                                  "operator"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "matchLabels": {
                              "additionalProperties": {
                                "type": "string"
                              },
                              "type": "object"
                            }
                          },
                          "type": "object",
                          "x-kubernetes-map-type": "atomic",
                          "additionalProperties": false
                        },
                        "namespaces": {
                          "items": {
                            "type": "string"
                          },
                          "type": "array",
                          "x-kubernetes-list-type": "atomic"
                        },
                        "topologyKey": {
                          "type": "string"
                        }
                      },
                      "required": [
                        "topologyKey"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "podAntiAffinity": {
                "properties": {
                  "preferredDuringSchedulingIgnoredDuringExecution": {
                    "items": {
                      "properties": {
                        "podAffinityTerm": {
                          "properties": {
                            "labelSelector": {
                              "properties": {
                                "matchExpressions": {
                                  "items": {
                                    "properties": {
                                      "key": {
                                        "type": "string"
                                      },
                                      "operator": {
                                        "type": "string"
                                      },
                                      "values": {
                                        "items": {
                                          "type": "string"
                                        },
                                        "type": "array",
                                        "x-kubernetes-list-type": "atomic"
                                      }
                                    },
                                    "required": [
                                      "key",
                                      "operator"
                                    ],
                                    "type": "object",
                                    "additionalProperties": false
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "matchLabels": {
                                  "additionalProperties": {
                                    "type": "string"
                                  },
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "x-kubernetes-map-type": "atomic",
                              "additionalProperties": false
                            },
                            "matchLabelKeys": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "mismatchLabelKeys": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "namespaceSelector": {
                              "properties": {
                                "matchExpressions": {
                                  "items": {
                                    "properties": {
                                      "key": {
                                        "type": "string"
                                      },
                                      "operator": {
                                        "type": "string"
                                      },
                                      "values": {
                                        "items": {
                                          "type": "string"
                                        },
                                        "type": "array",
                                        "x-kubernetes-list-type": "atomic"
                                      }
                                    },
                                    "required": [
                                      "key",
                                      "operator"
                                    ],
                                    "type": "object",
                                    "additionalProperties": false
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "matchLabels": {
                                  "additionalProperties": {
                                    "type": "string"
                                  },
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "x-kubernetes-map-type": "atomic",
                              "additionalProperties": false
                            },
                            "namespaces": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "topologyKey": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "topologyKey"
                          ],
                          "type": "object",
                          "additionalProperties": false
                        },
                        "weight": {
                          "format": "int32",
                          "type": "integer"
                        }
                      },
                      "required": [
                        "podAffinityTerm",
                        "weight"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  },
                  "requiredDuringSchedulingIgnoredDuringExecution": {
                    "items": {
                      "properties": {
                        "labelSelector": {
                          "properties": {
                            "matchExpressions": {
                              "items": {
                                "properties": {
                                  "key": {
                                    "type": "string"
                                  },
                                  "operator": {
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  }
                                },
                                "required": [
                                  "key",
                                  "operator"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "matchLabels": {
                              "additionalProperties": {
                                "type": "string"
                              },
                              "type": "object"
                            }
                          },
                          "type": "object",
                          "x-kubernetes-map-type": "atomic",
                          "additionalProperties": false
                        },
                        "matchLabelKeys": {
                          "items": {
                            "type": "string"
                          },
                          "type": "array",
                          "x-kubernetes-list-type": "atomic"
                        },
                        "mismatchLabelKeys": {
                          "items": {
                            "type": "string"
                          },
                          "type": "array",
                          "x-kubernetes-list-type": "atomic"
                        },
                        "namespaceSelector": {
                          "properties": {
                            "matchExpressions": {
                              "items": {
                                "properties": {
                                  "key": {
                                    "type": "string"
                                  },
                                  "operator": {
                                    "type": "string"
                                  },
                                  "values": {
                                    "items": {
                                      "type": "string"
                                    },
                                    "type": "array",
                                    "x-kubernetes-list-type": "atomic"
                                  }
                                },
                                "required": [
                                  "key",
                                  "operator"
                                ],
                                "type": "object",
                                "additionalProperties": false
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "matchLabels": {
                              "additionalProperties": {
                                "type": "string"
                              },
                              "type": "object"
                            }
                          },
                          "type": "object",
                          "x-kubernetes-map-type": "atomic",
                          "additionalProperties": false
                        },
                        "namespaces": {
                          "items": {
                            "type": "string"
                          },
                          "type": "array",
                          "x-kubernetes-list-type": "atomic"
                        },
                        "topologyKey": {
                          "type": "string"
                        }
                      },
                      "required": [
                        "topologyKey"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array",
                    "x-kubernetes-list-type": "atomic"
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "tolerations": {
                "items": {
                  "properties": {
                    "effect": {
                      "type": "string"
                    },
                    "key": {
                      "type": "string"
                    },
                    "operator": {
                      "type": "string"
                    },
                    "tolerationSeconds": {
                      "format": "int64",
                      "type": "integer"
                    },
                    "value": {
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              },
              "topologySpreadConstraints": {
                "items": {
                  "properties": {
                    "labelSelector": {
                      "properties": {
                        "matchExpressions": {
                          "items": {
                            "properties": {
                              "key": {
                                "type": "string"
                              },
                              "operator": {
                                "type": "string"
                              },
                              "values": {
                                "items": {
                                  "type": "string"
                                },
                                "type": "array",
                                "x-kubernetes-list-type": "atomic"
                              }
                            },
                            "required": [
                              "key",
                              "operator"
                            ],
                            "type": "object",
                            "additionalProperties": false
                          },
                          "type": "array",
                          "x-kubernetes-list-type": "atomic"
                        },
                        "matchLabels": {
                          "additionalProperties": {
                            "type": "string"
                          },
                          "type": "object"
                        }
                      },
                      "type": "object",
                      "x-kubernetes-map-type": "atomic",
                      "additionalProperties": false
                    },
                    "matchLabelKeys": {
                      "items": {
                        "type": "string"
                      },
                      "type": "array",
                      "x-kubernetes-list-type": "atomic"
                    },
                    "maxSkew": {
                      "format": "int32",
                      "type": "integer"
                    },
                    "minDomains": {
                      "format": "int32",
                      "type": "integer"
                    },
                    "nodeAffinityPolicy": {
                      "type": "string"
                    },
                    "nodeTaintsPolicy": {
                      "type": "string"
                    },
                    "topologyKey": {
                      "type": "string"
                    },
                    "whenUnsatisfiable": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "maxSkew",
                    "topologyKey",
                    "whenUnsatisfiable"
                  ],
                  "type": "object",
                  "additionalProperties": false
                },
                "type": "array"
              }
            },
            "type": "object",
            "additionalProperties": false
          },
          "nullable": true,
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "priorityClassNames": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "PriorityClassNames sets priority classes on components",
          "nullable": true,
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "removeOSDsIfOutAndSafeToRemove": {
          "description": "Remove the OSD that is out and safe to remove only if this option is true",
          "type": "boolean"
        },
        "resources": {
          "additionalProperties": {
            "description": "ResourceRequirements describes the compute resource requirements.",
            "properties": {
              "claims": {
                "description": "Claims lists the names of resources, defined in spec.resourceClaims,\nthat are used by this container.\n\nThis is an alpha field and requires enabling the\nDynamicResourceAllocation feature gate.\n\nThis 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\nthe Pod where this field is used. It makes that resource available\ninside a container.",
                      "type": "string"
                    },
                    "request": {
                      "description": "Request is the name chosen for a request in the referenced claim.\nIf empty, everything from the claim is made available, otherwise\nonly the result of this request.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "name"
                  ],
                  "type": "object",
                  "additionalProperties": false
                },
                "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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                "type": "object"
              }
            },
            "type": "object",
            "additionalProperties": false
          },
          "description": "Resources set resource requests and limits",
          "nullable": true,
          "type": "object",
          "x-kubernetes-preserve-unknown-fields": true
        },
        "security": {
          "description": "Security represents security settings",
          "nullable": true,
          "properties": {
            "keyRotation": {
              "description": "KeyRotation defines options for Key Rotation.",
              "nullable": true,
              "properties": {
                "enabled": {
                  "default": false,
                  "description": "Enabled represents whether the key rotation is enabled.",
                  "type": "boolean"
                },
                "schedule": {
                  "description": "Schedule represents the cron schedule for key rotation.",
                  "type": "string"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "kms": {
              "description": "KeyManagementService is the main Key Management option",
              "nullable": true,
              "properties": {
                "connectionDetails": {
                  "additionalProperties": {
                    "type": "string"
                  },
                  "description": "ConnectionDetails contains the KMS connection details (address, port etc)",
                  "nullable": true,
                  "type": "object",
                  "x-kubernetes-preserve-unknown-fields": true
                },
                "tokenSecretName": {
                  "description": "TokenSecretName is the kubernetes secret containing the KMS token",
                  "type": "string"
                }
              },
              "type": "object",
              "additionalProperties": false
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "skipUpgradeChecks": {
          "description": "SkipUpgradeChecks defines if an upgrade should be forced even if one of the check fails",
          "type": "boolean"
        },
        "storage": {
          "description": "A spec for available storage in the cluster and how it should be used",
          "nullable": true,
          "properties": {
            "allowDeviceClassUpdate": {
              "description": "Whether to allow updating the device class after the OSD is initially provisioned",
              "type": "boolean"
            },
            "allowOsdCrushWeightUpdate": {
              "description": "Whether Rook will resize the OSD CRUSH weight when the OSD PVC size is increased.\nThis allows cluster data to be rebalanced to make most effective use of new OSD space.\nThe default is false since data rebalancing can cause temporary cluster slowdown.",
              "type": "boolean"
            },
            "backfillFullRatio": {
              "description": "BackfillFullRatio is the ratio at which the cluster is too full for backfill. Backfill will be disabled if above this threshold. Default is 0.90.",
              "maximum": 1,
              "minimum": 0,
              "nullable": true,
              "type": "number"
            },
            "config": {
              "additionalProperties": {
                "type": "string"
              },
              "nullable": true,
              "type": "object",
              "x-kubernetes-preserve-unknown-fields": true
            },
            "deviceFilter": {
              "description": "A regular expression to allow more fine-grained selection of devices on nodes across the cluster",
              "type": "string"
            },
            "devicePathFilter": {
              "description": "A regular expression to allow more fine-grained selection of devices with path names",
              "type": "string"
            },
            "devices": {
              "description": "List of devices to use as storage devices",
              "items": {
                "description": "Device represents a disk to use in the cluster",
                "properties": {
                  "config": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "nullable": true,
                    "type": "object",
                    "x-kubernetes-preserve-unknown-fields": true
                  },
                  "fullpath": {
                    "type": "string"
                  },
                  "name": {
                    "type": "string"
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "nullable": true,
              "type": "array",
              "x-kubernetes-preserve-unknown-fields": true
            },
            "flappingRestartIntervalHours": {
              "description": "FlappingRestartIntervalHours defines the time for which the OSD pods, that failed with zero exit code, will sleep before restarting.\nThis is needed for OSD flapping where OSD daemons are marked down more than 5 times in 600 seconds by Ceph.\nPreventing the OSD pods to restart immediately in such scenarios will prevent Rook from marking OSD as `up` and thus\npeering of the PGs mapped to the OSD.\nUser needs to manually restart the OSD pod if they manage to fix the underlying OSD flapping issue before the restart interval.\nThe sleep will be disabled if this interval is set to 0.",
              "type": "integer"
            },
            "fullRatio": {
              "description": "FullRatio is the ratio at which the cluster is considered full and ceph will stop accepting writes. Default is 0.95.",
              "maximum": 1,
              "minimum": 0,
              "nullable": true,
              "type": "number"
            },
            "migration": {
              "description": "Migration handles the OSD migration",
              "properties": {
                "confirmation": {
                  "description": "A user confirmation to migrate the OSDs. It destroys each OSD one at a time, cleans up the backing disk\nand prepares OSD with same ID on that disk",
                  "pattern": "^$|^yes-really-migrate-osds$",
                  "type": "string"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "nearFullRatio": {
              "description": "NearFullRatio is the ratio at which the cluster is considered nearly full and will raise a ceph health warning. Default is 0.85.",
              "maximum": 1,
              "minimum": 0,
              "nullable": true,
              "type": "number"
            },
            "nodes": {
              "items": {
                "description": "Node is a storage nodes",
                "properties": {
                  "config": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "nullable": true,
                    "type": "object",
                    "x-kubernetes-preserve-unknown-fields": true
                  },
                  "deviceFilter": {
                    "description": "A regular expression to allow more fine-grained selection of devices on nodes across the cluster",
                    "type": "string"
                  },
                  "devicePathFilter": {
                    "description": "A regular expression to allow more fine-grained selection of devices with path names",
                    "type": "string"
                  },
                  "devices": {
                    "description": "List of devices to use as storage devices",
                    "items": {
                      "description": "Device represents a disk to use in the cluster",
                      "properties": {
                        "config": {
                          "additionalProperties": {
                            "type": "string"
                          },
                          "nullable": true,
                          "type": "object",
                          "x-kubernetes-preserve-unknown-fields": true
                        },
                        "fullpath": {
                          "type": "string"
                        },
                        "name": {
                          "type": "string"
                        }
                      },
                      "type": "object",
                      "additionalProperties": false
                    },
                    "nullable": true,
                    "type": "array",
                    "x-kubernetes-preserve-unknown-fields": true
                  },
                  "name": {
                    "type": "string"
                  },
                  "resources": {
                    "description": "ResourceRequirements describes the compute resource requirements.",
                    "nullable": true,
                    "properties": {
                      "claims": {
                        "description": "Claims lists the names of resources, defined in spec.resourceClaims,\nthat are used by this container.\n\nThis is an alpha field and requires enabling the\nDynamicResourceAllocation feature gate.\n\nThis 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\nthe Pod where this field is used. It makes that resource available\ninside a container.",
                              "type": "string"
                            },
                            "request": {
                              "description": "Request is the name chosen for a request in the referenced claim.\nIf empty, everything from the claim is made available, otherwise\nonly the result of this request.",
                              "type": "string"
                            }
                          },
                          "required": [
                            "name"
                          ],
                          "type": "object",
                          "additionalProperties": false
                        },
                        "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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-preserve-unknown-fields": true,
                    "additionalProperties": false
                  },
                  "useAllDevices": {
                    "description": "Whether to consume all the storage devices found on a machine",
                    "type": "boolean"
                  },
                  "volumeClaimTemplates": {
                    "description": "PersistentVolumeClaims to use as storage",
                    "items": {
                      "description": "VolumeClaimTemplate is a simplified version of K8s corev1's PVC. It has no type meta or status.",
                      "properties": {
                        "metadata": {
                          "description": "Standard object's metadata.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
                          "properties": {
                            "annotations": {
                              "additionalProperties": {
                                "type": "string"
                              },
                              "type": "object"
                            },
                            "finalizers": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            },
                            "labels": {
                              "additionalProperties": {
                                "type": "string"
                              },
                              "type": "object"
                            },
                            "name": {
                              "type": "string"
                            },
                            "namespace": {
                              "type": "string"
                            }
                          },
                          "type": "object",
                          "additionalProperties": false
                        },
                        "spec": {
                          "description": "spec defines the desired characteristics of a volume requested by a pod author.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims",
                          "properties": {
                            "accessModes": {
                              "description": "accessModes contains the desired access modes the volume should have.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1",
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "dataSource": {
                              "description": "dataSource field can be used to specify either:\n* An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)\n* An existing PVC (PersistentVolumeClaim)\nIf the provisioner or an external controller can support the specified data source,\nit will create a new volume based on the contents of the specified data source.\nWhen the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef,\nand dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified.\nIf the namespace is specified, then dataSourceRef will not be copied to dataSource.",
                              "properties": {
                                "apiGroup": {
                                  "description": "APIGroup is the group for the resource being referenced.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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",
                              "additionalProperties": false
                            },
                            "dataSourceRef": {
                              "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty\nvolume is desired. This may be any object from a non-empty API group (non\ncore object) or a PersistentVolumeClaim object.\nWhen this field is specified, volume binding will only succeed if the type of\nthe specified object matches some installed volume populator or dynamic\nprovisioner.\nThis field will replace the functionality of the dataSource field and as such\nif both fields are non-empty, they must have the same value. For backwards\ncompatibility, when namespace isn't specified in dataSourceRef,\nboth fields (dataSource and dataSourceRef) will be set to the same\nvalue automatically if one of them is empty and the other is non-empty.\nWhen namespace is specified in dataSourceRef,\ndataSource isn't set to the same value and must be empty.\nThere are three important differences between dataSource and dataSourceRef:\n* While dataSource only allows two specific types of objects, dataSourceRef\n  allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n  preserves all values, and generates an error if a disallowed value is\n  specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n  in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.\n(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.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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\nNote 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.\n(Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "kind",
                                "name"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "resources": {
                              "description": "resources represents the minimum resources the volume should have.\nIf RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements\nthat are lower than previous value but must still be higher than capacity recorded in the\nstatus field of the claim.\nMore 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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "additionalProperties": false
                            },
                            "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\nrelates 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.\nValid 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,\nthe values array must be non-empty. If the operator is Exists or DoesNotExist,\nthe values array must be empty. This array is replaced during a strategic\nmerge patch.",
                                        "items": {
                                          "type": "string"
                                        },
                                        "type": "array",
                                        "x-kubernetes-list-type": "atomic"
                                      }
                                    },
                                    "required": [
                                      "key",
                                      "operator"
                                    ],
                                    "type": "object",
                                    "additionalProperties": false
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "matchLabels": {
                                  "additionalProperties": {
                                    "type": "string"
                                  },
                                  "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels\nmap is equivalent to an element of matchExpressions, whose key field is \"key\", the\noperator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "x-kubernetes-map-type": "atomic",
                              "additionalProperties": false
                            },
                            "storageClassName": {
                              "description": "storageClassName is the name of the StorageClass required by the claim.\nMore 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.\nIf specified, the CSI driver will create or update the volume with the attributes defined\nin the corresponding VolumeAttributesClass. This has a different purpose than storageClassName,\nit can be changed after the claim is created. An empty string value means that no VolumeAttributesClass\nwill be applied to the claim but it's not allowed to reset this field to empty string once it is set.\nIf unspecified and the PersistentVolumeClaim is unbound, the default VolumeAttributesClass\nwill be set by the persistentvolume controller if it exists.\nIf the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be\nset to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource\nexists.\nMore info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\n(Beta) Using this field requires the VolumeAttributesClass feature gate to be enabled (off by default).",
                              "type": "string"
                            },
                            "volumeMode": {
                              "description": "volumeMode defines what type of volume is required by the claim.\nValue 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",
                          "additionalProperties": false
                        }
                      },
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array"
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "nullable": true,
              "type": "array"
            },
            "onlyApplyOSDPlacement": {
              "type": "boolean"
            },
            "scheduleAlways": {
              "description": "Whether to always schedule OSDs on a node even if the node is not currently scheduleable or ready",
              "type": "boolean"
            },
            "storageClassDeviceSets": {
              "items": {
                "description": "StorageClassDeviceSet is a storage class device set",
                "properties": {
                  "config": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "description": "Provider-specific device configuration",
                    "nullable": true,
                    "type": "object",
                    "x-kubernetes-preserve-unknown-fields": true
                  },
                  "count": {
                    "description": "Count is the number of devices in this set",
                    "minimum": 1,
                    "type": "integer"
                  },
                  "encrypted": {
                    "description": "Whether to encrypt the deviceSet",
                    "type": "boolean"
                  },
                  "name": {
                    "description": "Name is a unique identifier for the set",
                    "type": "string"
                  },
                  "placement": {
                    "nullable": true,
                    "properties": {
                      "nodeAffinity": {
                        "properties": {
                          "preferredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "preference": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchFields": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "weight": {
                                  "format": "int32",
                                  "type": "integer"
                                }
                              },
                              "required": [
                                "preference",
                                "weight"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "requiredDuringSchedulingIgnoredDuringExecution": {
                            "properties": {
                              "nodeSelectorTerms": {
                                "items": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchFields": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "type": "array",
                                "x-kubernetes-list-type": "atomic"
                              }
                            },
                            "required": [
                              "nodeSelectorTerms"
                            ],
                            "type": "object",
                            "x-kubernetes-map-type": "atomic",
                            "additionalProperties": false
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "podAffinity": {
                        "properties": {
                          "preferredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "podAffinityTerm": {
                                  "properties": {
                                    "labelSelector": {
                                      "properties": {
                                        "matchExpressions": {
                                          "items": {
                                            "properties": {
                                              "key": {
                                                "type": "string"
                                              },
                                              "operator": {
                                                "type": "string"
                                              },
                                              "values": {
                                                "items": {
                                                  "type": "string"
                                                },
                                                "type": "array",
                                                "x-kubernetes-list-type": "atomic"
                                              }
                                            },
                                            "required": [
                                              "key",
                                              "operator"
                                            ],
                                            "type": "object",
                                            "additionalProperties": false
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        },
                                        "matchLabels": {
                                          "additionalProperties": {
                                            "type": "string"
                                          },
                                          "type": "object"
                                        }
                                      },
                                      "type": "object",
                                      "x-kubernetes-map-type": "atomic",
                                      "additionalProperties": false
                                    },
                                    "matchLabelKeys": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "mismatchLabelKeys": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "namespaceSelector": {
                                      "properties": {
                                        "matchExpressions": {
                                          "items": {
                                            "properties": {
                                              "key": {
                                                "type": "string"
                                              },
                                              "operator": {
                                                "type": "string"
                                              },
                                              "values": {
                                                "items": {
                                                  "type": "string"
                                                },
                                                "type": "array",
                                                "x-kubernetes-list-type": "atomic"
                                              }
                                            },
                                            "required": [
                                              "key",
                                              "operator"
                                            ],
                                            "type": "object",
                                            "additionalProperties": false
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        },
                                        "matchLabels": {
                                          "additionalProperties": {
                                            "type": "string"
                                          },
                                          "type": "object"
                                        }
                                      },
                                      "type": "object",
                                      "x-kubernetes-map-type": "atomic",
                                      "additionalProperties": false
                                    },
                                    "namespaces": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "topologyKey": {
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "topologyKey"
                                  ],
                                  "type": "object",
                                  "additionalProperties": false
                                },
                                "weight": {
                                  "format": "int32",
                                  "type": "integer"
                                }
                              },
                              "required": [
                                "podAffinityTerm",
                                "weight"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "requiredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "labelSelector": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchLabels": {
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "type": "object"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "matchLabelKeys": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "mismatchLabelKeys": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "namespaceSelector": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchLabels": {
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "type": "object"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "namespaces": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "topologyKey": {
                                  "type": "string"
                                }
                              },
                              "required": [
                                "topologyKey"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "podAntiAffinity": {
                        "properties": {
                          "preferredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "podAffinityTerm": {
                                  "properties": {
                                    "labelSelector": {
                                      "properties": {
                                        "matchExpressions": {
                                          "items": {
                                            "properties": {
                                              "key": {
                                                "type": "string"
                                              },
                                              "operator": {
                                                "type": "string"
                                              },
                                              "values": {
                                                "items": {
                                                  "type": "string"
                                                },
                                                "type": "array",
                                                "x-kubernetes-list-type": "atomic"
                                              }
                                            },
                                            "required": [
                                              "key",
                                              "operator"
                                            ],
                                            "type": "object",
                                            "additionalProperties": false
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        },
                                        "matchLabels": {
                                          "additionalProperties": {
                                            "type": "string"
                                          },
                                          "type": "object"
                                        }
                                      },
                                      "type": "object",
                                      "x-kubernetes-map-type": "atomic",
                                      "additionalProperties": false
                                    },
                                    "matchLabelKeys": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "mismatchLabelKeys": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "namespaceSelector": {
                                      "properties": {
                                        "matchExpressions": {
                                          "items": {
                                            "properties": {
                                              "key": {
                                                "type": "string"
                                              },
                                              "operator": {
                                                "type": "string"
                                              },
                                              "values": {
                                                "items": {
                                                  "type": "string"
                                                },
                                                "type": "array",
                                                "x-kubernetes-list-type": "atomic"
                                              }
                                            },
                                            "required": [
                                              "key",
                                              "operator"
                                            ],
                                            "type": "object",
                                            "additionalProperties": false
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        },
                                        "matchLabels": {
                                          "additionalProperties": {
                                            "type": "string"
                                          },
                                          "type": "object"
                                        }
                                      },
                                      "type": "object",
                                      "x-kubernetes-map-type": "atomic",
                                      "additionalProperties": false
                                    },
                                    "namespaces": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "topologyKey": {
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "topologyKey"
                                  ],
                                  "type": "object",
                                  "additionalProperties": false
                                },
                                "weight": {
                                  "format": "int32",
                                  "type": "integer"
                                }
                              },
                              "required": [
                                "podAffinityTerm",
                                "weight"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "requiredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "labelSelector": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchLabels": {
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "type": "object"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "matchLabelKeys": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "mismatchLabelKeys": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "namespaceSelector": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchLabels": {
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "type": "object"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "namespaces": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "topologyKey": {
                                  "type": "string"
                                }
                              },
                              "required": [
                                "topologyKey"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "tolerations": {
                        "items": {
                          "properties": {
                            "effect": {
                              "type": "string"
                            },
                            "key": {
                              "type": "string"
                            },
                            "operator": {
                              "type": "string"
                            },
                            "tolerationSeconds": {
                              "format": "int64",
                              "type": "integer"
                            },
                            "value": {
                              "type": "string"
                            }
                          },
                          "type": "object",
                          "additionalProperties": false
                        },
                        "type": "array"
                      },
                      "topologySpreadConstraints": {
                        "items": {
                          "properties": {
                            "labelSelector": {
                              "properties": {
                                "matchExpressions": {
                                  "items": {
                                    "properties": {
                                      "key": {
                                        "type": "string"
                                      },
                                      "operator": {
                                        "type": "string"
                                      },
                                      "values": {
                                        "items": {
                                          "type": "string"
                                        },
                                        "type": "array",
                                        "x-kubernetes-list-type": "atomic"
                                      }
                                    },
                                    "required": [
                                      "key",
                                      "operator"
                                    ],
                                    "type": "object",
                                    "additionalProperties": false
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "matchLabels": {
                                  "additionalProperties": {
                                    "type": "string"
                                  },
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "x-kubernetes-map-type": "atomic",
                              "additionalProperties": false
                            },
                            "matchLabelKeys": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "maxSkew": {
                              "format": "int32",
                              "type": "integer"
                            },
                            "minDomains": {
                              "format": "int32",
                              "type": "integer"
                            },
                            "nodeAffinityPolicy": {
                              "type": "string"
                            },
                            "nodeTaintsPolicy": {
                              "type": "string"
                            },
                            "topologyKey": {
                              "type": "string"
                            },
                            "whenUnsatisfiable": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "maxSkew",
                            "topologyKey",
                            "whenUnsatisfiable"
                          ],
                          "type": "object",
                          "additionalProperties": false
                        },
                        "type": "array"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-preserve-unknown-fields": true,
                    "additionalProperties": false
                  },
                  "portable": {
                    "description": "Portable represents OSD portability across the hosts",
                    "type": "boolean"
                  },
                  "preparePlacement": {
                    "nullable": true,
                    "properties": {
                      "nodeAffinity": {
                        "properties": {
                          "preferredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "preference": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchFields": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "weight": {
                                  "format": "int32",
                                  "type": "integer"
                                }
                              },
                              "required": [
                                "preference",
                                "weight"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "requiredDuringSchedulingIgnoredDuringExecution": {
                            "properties": {
                              "nodeSelectorTerms": {
                                "items": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchFields": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "type": "array",
                                "x-kubernetes-list-type": "atomic"
                              }
                            },
                            "required": [
                              "nodeSelectorTerms"
                            ],
                            "type": "object",
                            "x-kubernetes-map-type": "atomic",
                            "additionalProperties": false
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "podAffinity": {
                        "properties": {
                          "preferredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "podAffinityTerm": {
                                  "properties": {
                                    "labelSelector": {
                                      "properties": {
                                        "matchExpressions": {
                                          "items": {
                                            "properties": {
                                              "key": {
                                                "type": "string"
                                              },
                                              "operator": {
                                                "type": "string"
                                              },
                                              "values": {
                                                "items": {
                                                  "type": "string"
                                                },
                                                "type": "array",
                                                "x-kubernetes-list-type": "atomic"
                                              }
                                            },
                                            "required": [
                                              "key",
                                              "operator"
                                            ],
                                            "type": "object",
                                            "additionalProperties": false
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        },
                                        "matchLabels": {
                                          "additionalProperties": {
                                            "type": "string"
                                          },
                                          "type": "object"
                                        }
                                      },
                                      "type": "object",
                                      "x-kubernetes-map-type": "atomic",
                                      "additionalProperties": false
                                    },
                                    "matchLabelKeys": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "mismatchLabelKeys": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "namespaceSelector": {
                                      "properties": {
                                        "matchExpressions": {
                                          "items": {
                                            "properties": {
                                              "key": {
                                                "type": "string"
                                              },
                                              "operator": {
                                                "type": "string"
                                              },
                                              "values": {
                                                "items": {
                                                  "type": "string"
                                                },
                                                "type": "array",
                                                "x-kubernetes-list-type": "atomic"
                                              }
                                            },
                                            "required": [
                                              "key",
                                              "operator"
                                            ],
                                            "type": "object",
                                            "additionalProperties": false
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        },
                                        "matchLabels": {
                                          "additionalProperties": {
                                            "type": "string"
                                          },
                                          "type": "object"
                                        }
                                      },
                                      "type": "object",
                                      "x-kubernetes-map-type": "atomic",
                                      "additionalProperties": false
                                    },
                                    "namespaces": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "topologyKey": {
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "topologyKey"
                                  ],
                                  "type": "object",
                                  "additionalProperties": false
                                },
                                "weight": {
                                  "format": "int32",
                                  "type": "integer"
                                }
                              },
                              "required": [
                                "podAffinityTerm",
                                "weight"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "requiredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "labelSelector": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchLabels": {
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "type": "object"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "matchLabelKeys": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "mismatchLabelKeys": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "namespaceSelector": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchLabels": {
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "type": "object"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "namespaces": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "topologyKey": {
                                  "type": "string"
                                }
                              },
                              "required": [
                                "topologyKey"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "podAntiAffinity": {
                        "properties": {
                          "preferredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "podAffinityTerm": {
                                  "properties": {
                                    "labelSelector": {
                                      "properties": {
                                        "matchExpressions": {
                                          "items": {
                                            "properties": {
                                              "key": {
                                                "type": "string"
                                              },
                                              "operator": {
                                                "type": "string"
                                              },
                                              "values": {
                                                "items": {
                                                  "type": "string"
                                                },
                                                "type": "array",
                                                "x-kubernetes-list-type": "atomic"
                                              }
                                            },
                                            "required": [
                                              "key",
                                              "operator"
                                            ],
                                            "type": "object",
                                            "additionalProperties": false
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        },
                                        "matchLabels": {
                                          "additionalProperties": {
                                            "type": "string"
                                          },
                                          "type": "object"
                                        }
                                      },
                                      "type": "object",
                                      "x-kubernetes-map-type": "atomic",
                                      "additionalProperties": false
                                    },
                                    "matchLabelKeys": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "mismatchLabelKeys": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "namespaceSelector": {
                                      "properties": {
                                        "matchExpressions": {
                                          "items": {
                                            "properties": {
                                              "key": {
                                                "type": "string"
                                              },
                                              "operator": {
                                                "type": "string"
                                              },
                                              "values": {
                                                "items": {
                                                  "type": "string"
                                                },
                                                "type": "array",
                                                "x-kubernetes-list-type": "atomic"
                                              }
                                            },
                                            "required": [
                                              "key",
                                              "operator"
                                            ],
                                            "type": "object",
                                            "additionalProperties": false
                                          },
                                          "type": "array",
                                          "x-kubernetes-list-type": "atomic"
                                        },
                                        "matchLabels": {
                                          "additionalProperties": {
                                            "type": "string"
                                          },
                                          "type": "object"
                                        }
                                      },
                                      "type": "object",
                                      "x-kubernetes-map-type": "atomic",
                                      "additionalProperties": false
                                    },
                                    "namespaces": {
                                      "items": {
                                        "type": "string"
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "topologyKey": {
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "topologyKey"
                                  ],
                                  "type": "object",
                                  "additionalProperties": false
                                },
                                "weight": {
                                  "format": "int32",
                                  "type": "integer"
                                }
                              },
                              "required": [
                                "podAffinityTerm",
                                "weight"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "requiredDuringSchedulingIgnoredDuringExecution": {
                            "items": {
                              "properties": {
                                "labelSelector": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchLabels": {
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "type": "object"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "matchLabelKeys": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "mismatchLabelKeys": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "namespaceSelector": {
                                  "properties": {
                                    "matchExpressions": {
                                      "items": {
                                        "properties": {
                                          "key": {
                                            "type": "string"
                                          },
                                          "operator": {
                                            "type": "string"
                                          },
                                          "values": {
                                            "items": {
                                              "type": "string"
                                            },
                                            "type": "array",
                                            "x-kubernetes-list-type": "atomic"
                                          }
                                        },
                                        "required": [
                                          "key",
                                          "operator"
                                        ],
                                        "type": "object",
                                        "additionalProperties": false
                                      },
                                      "type": "array",
                                      "x-kubernetes-list-type": "atomic"
                                    },
                                    "matchLabels": {
                                      "additionalProperties": {
                                        "type": "string"
                                      },
                                      "type": "object"
                                    }
                                  },
                                  "type": "object",
                                  "x-kubernetes-map-type": "atomic",
                                  "additionalProperties": false
                                },
                                "namespaces": {
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "topologyKey": {
                                  "type": "string"
                                }
                              },
                              "required": [
                                "topologyKey"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "tolerations": {
                        "items": {
                          "properties": {
                            "effect": {
                              "type": "string"
                            },
                            "key": {
                              "type": "string"
                            },
                            "operator": {
                              "type": "string"
                            },
                            "tolerationSeconds": {
                              "format": "int64",
                              "type": "integer"
                            },
                            "value": {
                              "type": "string"
                            }
                          },
                          "type": "object",
                          "additionalProperties": false
                        },
                        "type": "array"
                      },
                      "topologySpreadConstraints": {
                        "items": {
                          "properties": {
                            "labelSelector": {
                              "properties": {
                                "matchExpressions": {
                                  "items": {
                                    "properties": {
                                      "key": {
                                        "type": "string"
                                      },
                                      "operator": {
                                        "type": "string"
                                      },
                                      "values": {
                                        "items": {
                                          "type": "string"
                                        },
                                        "type": "array",
                                        "x-kubernetes-list-type": "atomic"
                                      }
                                    },
                                    "required": [
                                      "key",
                                      "operator"
                                    ],
                                    "type": "object",
                                    "additionalProperties": false
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "matchLabels": {
                                  "additionalProperties": {
                                    "type": "string"
                                  },
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "x-kubernetes-map-type": "atomic",
                              "additionalProperties": false
                            },
                            "matchLabelKeys": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "maxSkew": {
                              "format": "int32",
                              "type": "integer"
                            },
                            "minDomains": {
                              "format": "int32",
                              "type": "integer"
                            },
                            "nodeAffinityPolicy": {
                              "type": "string"
                            },
                            "nodeTaintsPolicy": {
                              "type": "string"
                            },
                            "topologyKey": {
                              "type": "string"
                            },
                            "whenUnsatisfiable": {
                              "type": "string"
                            }
                          },
                          "required": [
                            "maxSkew",
                            "topologyKey",
                            "whenUnsatisfiable"
                          ],
                          "type": "object",
                          "additionalProperties": false
                        },
                        "type": "array"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-preserve-unknown-fields": true,
                    "additionalProperties": false
                  },
                  "resources": {
                    "description": "ResourceRequirements describes the compute resource requirements.",
                    "nullable": true,
                    "properties": {
                      "claims": {
                        "description": "Claims lists the names of resources, defined in spec.resourceClaims,\nthat are used by this container.\n\nThis is an alpha field and requires enabling the\nDynamicResourceAllocation feature gate.\n\nThis 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\nthe Pod where this field is used. It makes that resource available\ninside a container.",
                              "type": "string"
                            },
                            "request": {
                              "description": "Request is the name chosen for a request in the referenced claim.\nIf empty, everything from the claim is made available, otherwise\nonly the result of this request.",
                              "type": "string"
                            }
                          },
                          "required": [
                            "name"
                          ],
                          "type": "object",
                          "additionalProperties": false
                        },
                        "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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                        "type": "object"
                      }
                    },
                    "type": "object",
                    "x-kubernetes-preserve-unknown-fields": true,
                    "additionalProperties": false
                  },
                  "schedulerName": {
                    "description": "Scheduler name for OSD pod placement",
                    "type": "string"
                  },
                  "tuneDeviceClass": {
                    "description": "TuneSlowDeviceClass Tune the OSD when running on a slow Device Class",
                    "type": "boolean"
                  },
                  "tuneFastDeviceClass": {
                    "description": "TuneFastDeviceClass Tune the OSD when running on a fast Device Class",
                    "type": "boolean"
                  },
                  "volumeClaimTemplates": {
                    "description": "VolumeClaimTemplates is a list of PVC templates for the underlying storage devices",
                    "items": {
                      "description": "VolumeClaimTemplate is a simplified version of K8s corev1's PVC. It has no type meta or status.",
                      "properties": {
                        "metadata": {
                          "description": "Standard object's metadata.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
                          "properties": {
                            "annotations": {
                              "additionalProperties": {
                                "type": "string"
                              },
                              "type": "object",
                              "x-kubernetes-preserve-unknown-fields": true
                            },
                            "finalizers": {
                              "items": {
                                "type": "string"
                              },
                              "type": "array"
                            },
                            "labels": {
                              "additionalProperties": {
                                "type": "string"
                              },
                              "type": "object"
                            },
                            "name": {
                              "type": "string"
                            },
                            "namespace": {
                              "type": "string"
                            }
                          },
                          "type": "object",
                          "additionalProperties": false
                        },
                        "spec": {
                          "description": "spec defines the desired characteristics of a volume requested by a pod author.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims",
                          "properties": {
                            "accessModes": {
                              "description": "accessModes contains the desired access modes the volume should have.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1",
                              "items": {
                                "type": "string"
                              },
                              "type": "array",
                              "x-kubernetes-list-type": "atomic"
                            },
                            "dataSource": {
                              "description": "dataSource field can be used to specify either:\n* An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)\n* An existing PVC (PersistentVolumeClaim)\nIf the provisioner or an external controller can support the specified data source,\nit will create a new volume based on the contents of the specified data source.\nWhen the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef,\nand dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified.\nIf the namespace is specified, then dataSourceRef will not be copied to dataSource.",
                              "properties": {
                                "apiGroup": {
                                  "description": "APIGroup is the group for the resource being referenced.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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",
                              "additionalProperties": false
                            },
                            "dataSourceRef": {
                              "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty\nvolume is desired. This may be any object from a non-empty API group (non\ncore object) or a PersistentVolumeClaim object.\nWhen this field is specified, volume binding will only succeed if the type of\nthe specified object matches some installed volume populator or dynamic\nprovisioner.\nThis field will replace the functionality of the dataSource field and as such\nif both fields are non-empty, they must have the same value. For backwards\ncompatibility, when namespace isn't specified in dataSourceRef,\nboth fields (dataSource and dataSourceRef) will be set to the same\nvalue automatically if one of them is empty and the other is non-empty.\nWhen namespace is specified in dataSourceRef,\ndataSource isn't set to the same value and must be empty.\nThere are three important differences between dataSource and dataSourceRef:\n* While dataSource only allows two specific types of objects, dataSourceRef\n  allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n  preserves all values, and generates an error if a disallowed value is\n  specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n  in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.\n(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.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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\nNote 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.\n(Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "kind",
                                "name"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "resources": {
                              "description": "resources represents the minimum resources the volume should have.\nIf RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements\nthat are lower than previous value but must still be higher than capacity recorded in the\nstatus field of the claim.\nMore 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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "additionalProperties": false
                            },
                            "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\nrelates 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.\nValid 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,\nthe values array must be non-empty. If the operator is Exists or DoesNotExist,\nthe values array must be empty. This array is replaced during a strategic\nmerge patch.",
                                        "items": {
                                          "type": "string"
                                        },
                                        "type": "array",
                                        "x-kubernetes-list-type": "atomic"
                                      }
                                    },
                                    "required": [
                                      "key",
                                      "operator"
                                    ],
                                    "type": "object",
                                    "additionalProperties": false
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                },
                                "matchLabels": {
                                  "additionalProperties": {
                                    "type": "string"
                                  },
                                  "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels\nmap is equivalent to an element of matchExpressions, whose key field is \"key\", the\noperator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                                  "type": "object"
                                }
                              },
                              "type": "object",
                              "x-kubernetes-map-type": "atomic",
                              "additionalProperties": false
                            },
                            "storageClassName": {
                              "description": "storageClassName is the name of the StorageClass required by the claim.\nMore 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.\nIf specified, the CSI driver will create or update the volume with the attributes defined\nin the corresponding VolumeAttributesClass. This has a different purpose than storageClassName,\nit can be changed after the claim is created. An empty string value means that no VolumeAttributesClass\nwill be applied to the claim but it's not allowed to reset this field to empty string once it is set.\nIf unspecified and the PersistentVolumeClaim is unbound, the default VolumeAttributesClass\nwill be set by the persistentvolume controller if it exists.\nIf the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be\nset to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource\nexists.\nMore info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\n(Beta) Using this field requires the VolumeAttributesClass feature gate to be enabled (off by default).",
                              "type": "string"
                            },
                            "volumeMode": {
                              "description": "volumeMode defines what type of volume is required by the claim.\nValue 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",
                          "additionalProperties": false
                        }
                      },
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array"
                  }
                },
                "required": [
                  "count",
                  "name",
                  "volumeClaimTemplates"
                ],
                "type": "object",
                "additionalProperties": false
              },
              "nullable": true,
              "type": "array"
            },
            "store": {
              "description": "OSDStore is the backend storage type used for creating the OSDs",
              "properties": {
                "type": {
                  "description": "Type of backend storage to be used while creating OSDs. If empty, then bluestore will be used",
                  "enum": [
                    "bluestore",
                    "bluestore-rdr"
                  ],
                  "type": "string"
                },
                "updateStore": {
                  "description": "UpdateStore updates the backend store for existing OSDs. It destroys each OSD one at a time, cleans up the backing disk\nand prepares same OSD on that disk",
                  "pattern": "^$|^yes-really-update-store$",
                  "type": "string"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "useAllDevices": {
              "description": "Whether to consume all the storage devices found on a machine",
              "type": "boolean"
            },
            "useAllNodes": {
              "type": "boolean"
            },
            "volumeClaimTemplates": {
              "description": "PersistentVolumeClaims to use as storage",
              "items": {
                "description": "VolumeClaimTemplate is a simplified version of K8s corev1's PVC. It has no type meta or status.",
                "properties": {
                  "metadata": {
                    "description": "Standard object's metadata.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
                    "properties": {
                      "annotations": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "finalizers": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      },
                      "labels": {
                        "additionalProperties": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "name": {
                        "type": "string"
                      },
                      "namespace": {
                        "type": "string"
                      }
                    },
                    "type": "object",
                    "additionalProperties": false
                  },
                  "spec": {
                    "description": "spec defines the desired characteristics of a volume requested by a pod author.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims",
                    "properties": {
                      "accessModes": {
                        "description": "accessModes contains the desired access modes the volume should have.\nMore info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1",
                        "items": {
                          "type": "string"
                        },
                        "type": "array",
                        "x-kubernetes-list-type": "atomic"
                      },
                      "dataSource": {
                        "description": "dataSource field can be used to specify either:\n* An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)\n* An existing PVC (PersistentVolumeClaim)\nIf the provisioner or an external controller can support the specified data source,\nit will create a new volume based on the contents of the specified data source.\nWhen the AnyVolumeDataSource feature gate is enabled, dataSource contents will be copied to dataSourceRef,\nand dataSourceRef contents will be copied to dataSource when dataSourceRef.namespace is not specified.\nIf the namespace is specified, then dataSourceRef will not be copied to dataSource.",
                        "properties": {
                          "apiGroup": {
                            "description": "APIGroup is the group for the resource being referenced.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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",
                        "additionalProperties": false
                      },
                      "dataSourceRef": {
                        "description": "dataSourceRef specifies the object from which to populate the volume with data, if a non-empty\nvolume is desired. This may be any object from a non-empty API group (non\ncore object) or a PersistentVolumeClaim object.\nWhen this field is specified, volume binding will only succeed if the type of\nthe specified object matches some installed volume populator or dynamic\nprovisioner.\nThis field will replace the functionality of the dataSource field and as such\nif both fields are non-empty, they must have the same value. For backwards\ncompatibility, when namespace isn't specified in dataSourceRef,\nboth fields (dataSource and dataSourceRef) will be set to the same\nvalue automatically if one of them is empty and the other is non-empty.\nWhen namespace is specified in dataSourceRef,\ndataSource isn't set to the same value and must be empty.\nThere are three important differences between dataSource and dataSourceRef:\n* While dataSource only allows two specific types of objects, dataSourceRef\n  allows any non-core object, as well as PersistentVolumeClaim objects.\n* While dataSource ignores disallowed values (dropping them), dataSourceRef\n  preserves all values, and generates an error if a disallowed value is\n  specified.\n* While dataSource only allows local objects, dataSourceRef allows objects\n  in any namespaces.\n(Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled.\n(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.\nIf APIGroup is not specified, the specified Kind must be in the core API group.\nFor 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\nNote 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.\n(Alpha) This field requires the CrossNamespaceVolumeDataSource feature gate to be enabled.",
                            "type": "string"
                          }
                        },
                        "required": [
                          "kind",
                          "name"
                        ],
                        "type": "object",
                        "additionalProperties": false
                      },
                      "resources": {
                        "description": "resources represents the minimum resources the volume should have.\nIf RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements\nthat are lower than previous value but must still be higher than capacity recorded in the\nstatus field of the claim.\nMore 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.\nMore 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.\nIf Requests is omitted for a container, it defaults to Limits if that is explicitly specified,\notherwise to an implementation-defined value. Requests cannot exceed Limits.\nMore info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/",
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "additionalProperties": false
                      },
                      "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\nrelates 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.\nValid 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,\nthe values array must be non-empty. If the operator is Exists or DoesNotExist,\nthe values array must be empty. This array is replaced during a strategic\nmerge patch.",
                                  "items": {
                                    "type": "string"
                                  },
                                  "type": "array",
                                  "x-kubernetes-list-type": "atomic"
                                }
                              },
                              "required": [
                                "key",
                                "operator"
                              ],
                              "type": "object",
                              "additionalProperties": false
                            },
                            "type": "array",
                            "x-kubernetes-list-type": "atomic"
                          },
                          "matchLabels": {
                            "additionalProperties": {
                              "type": "string"
                            },
                            "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels\nmap is equivalent to an element of matchExpressions, whose key field is \"key\", the\noperator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                            "type": "object"
                          }
                        },
                        "type": "object",
                        "x-kubernetes-map-type": "atomic",
                        "additionalProperties": false
                      },
                      "storageClassName": {
                        "description": "storageClassName is the name of the StorageClass required by the claim.\nMore 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.\nIf specified, the CSI driver will create or update the volume with the attributes defined\nin the corresponding VolumeAttributesClass. This has a different purpose than storageClassName,\nit can be changed after the claim is created. An empty string value means that no VolumeAttributesClass\nwill be applied to the claim but it's not allowed to reset this field to empty string once it is set.\nIf unspecified and the PersistentVolumeClaim is unbound, the default VolumeAttributesClass\nwill be set by the persistentvolume controller if it exists.\nIf the resource referred to by volumeAttributesClass does not exist, this PersistentVolumeClaim will be\nset to a Pending state, as reflected by the modifyVolumeStatus field, until such as a resource\nexists.\nMore info: https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/\n(Beta) Using this field requires the VolumeAttributesClass feature gate to be enabled (off by default).",
                        "type": "string"
                      },
                      "volumeMode": {
                        "description": "volumeMode defines what type of volume is required by the claim.\nValue 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",
                    "additionalProperties": false
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "type": "array"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "upgradeOSDRequiresHealthyPGs": {
          "description": "UpgradeOSDRequiresHealthyPGs defines if OSD upgrade requires PGs are clean. If set to `true` OSD upgrade process won't start until PGs are healthy.\nThis configuration will be ignored if `skipUpgradeChecks` is `true`.\nDefault is false.",
          "type": "boolean"
        },
        "waitTimeoutForHealthyOSDInMinutes": {
          "description": "WaitTimeoutForHealthyOSDInMinutes defines the time the operator would wait before an OSD can be stopped for upgrade or restart.\nIf the timeout exceeds and OSD is not ok to stop, then the operator would skip upgrade for the current OSD and proceed with the next one\nif `continueUpgradeAfterChecksEvenIfNotHealthy` is `false`. If `continueUpgradeAfterChecksEvenIfNotHealthy` is `true`, then operator would\ncontinue with the upgrade of an OSD even if its not ok to stop after the timeout. This timeout won't be applied if `skipUpgradeChecks` is `true`.\nThe default wait timeout is 10 minutes.",
          "format": "int64",
          "type": "integer"
        }
      },
      "type": "object",
      "additionalProperties": false
    },
    "status": {
      "description": "ClusterStatus represents the status of a Ceph cluster",
      "nullable": true,
      "properties": {
        "ceph": {
          "description": "CephStatus is the details health of a Ceph Cluster",
          "properties": {
            "capacity": {
              "description": "Capacity is the capacity information of a Ceph Cluster",
              "properties": {
                "bytesAvailable": {
                  "format": "int64",
                  "type": "integer"
                },
                "bytesTotal": {
                  "format": "int64",
                  "type": "integer"
                },
                "bytesUsed": {
                  "format": "int64",
                  "type": "integer"
                },
                "lastUpdated": {
                  "type": "string"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "details": {
              "additionalProperties": {
                "description": "CephHealthMessage represents the health message of a Ceph Cluster",
                "properties": {
                  "message": {
                    "type": "string"
                  },
                  "severity": {
                    "type": "string"
                  }
                },
                "required": [
                  "message",
                  "severity"
                ],
                "type": "object",
                "additionalProperties": false
              },
              "type": "object"
            },
            "fsid": {
              "type": "string"
            },
            "health": {
              "type": "string"
            },
            "lastChanged": {
              "type": "string"
            },
            "lastChecked": {
              "type": "string"
            },
            "previousHealth": {
              "type": "string"
            },
            "versions": {
              "description": "CephDaemonsVersions show the current ceph version for different ceph daemons",
              "properties": {
                "cephfs-mirror": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "CephFSMirror shows CephFSMirror Ceph version",
                  "type": "object"
                },
                "mds": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "Mds shows Mds Ceph version",
                  "type": "object"
                },
                "mgr": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "Mgr shows Mgr Ceph version",
                  "type": "object"
                },
                "mon": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "Mon shows Mon Ceph version",
                  "type": "object"
                },
                "osd": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "Osd shows Osd Ceph version",
                  "type": "object"
                },
                "overall": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "Overall shows overall Ceph version",
                  "type": "object"
                },
                "rbd-mirror": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "RbdMirror shows RbdMirror Ceph version",
                  "type": "object"
                },
                "rgw": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "Rgw shows Rgw Ceph version",
                  "type": "object"
                }
              },
              "type": "object",
              "additionalProperties": false
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "conditions": {
          "items": {
            "description": "Condition represents a status condition on any Rook-Ceph Custom Resource.",
            "properties": {
              "lastHeartbeatTime": {
                "format": "date-time",
                "type": "string"
              },
              "lastTransitionTime": {
                "format": "date-time",
                "type": "string"
              },
              "message": {
                "type": "string"
              },
              "reason": {
                "description": "ConditionReason is a reason for a condition",
                "type": "string"
              },
              "status": {
                "type": "string"
              },
              "type": {
                "description": "ConditionType represent a resource's status",
                "type": "string"
              }
            },
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        },
        "message": {
          "type": "string"
        },
        "observedGeneration": {
          "description": "ObservedGeneration is the latest generation observed by the controller.",
          "format": "int64",
          "type": "integer"
        },
        "phase": {
          "description": "ConditionType represent a resource's status",
          "type": "string"
        },
        "state": {
          "description": "ClusterState represents the state of a Ceph Cluster",
          "type": "string"
        },
        "storage": {
          "description": "CephStorage represents flavors of Ceph Cluster Storage",
          "properties": {
            "deprecatedOSDs": {
              "additionalProperties": {
                "items": {
                  "type": "integer"
                },
                "type": "array"
              },
              "type": "object"
            },
            "deviceClasses": {
              "items": {
                "description": "DeviceClasses represents device classes of a Ceph Cluster",
                "properties": {
                  "name": {
                    "type": "string"
                  }
                },
                "type": "object",
                "additionalProperties": false
              },
              "type": "array"
            },
            "osd": {
              "description": "OSDStatus represents OSD status of the ceph Cluster",
              "properties": {
                "migrationStatus": {
                  "description": "MigrationStatus status represents the current status of any OSD migration.",
                  "properties": {
                    "pending": {
                      "type": "integer"
                    }
                  },
                  "type": "object",
                  "additionalProperties": false
                },
                "storeType": {
                  "additionalProperties": {
                    "type": "integer"
                  },
                  "description": "StoreType is a mapping between the OSD backend stores and number of OSDs using these stores",
                  "type": "object"
                }
              },
              "type": "object",
              "additionalProperties": false
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "version": {
          "description": "ClusterVersion represents the version of a Ceph Cluster",
          "properties": {
            "image": {
              "type": "string"
            },
            "version": {
              "type": "string"
            }
          },
          "type": "object",
          "additionalProperties": false
        }
      },
      "type": "object",
      "x-kubernetes-preserve-unknown-fields": true,
      "additionalProperties": false
    }
  },
  "required": [
    "metadata",
    "spec"
  ],
  "type": "object"
}