kcr_org_eclipse_che 3.20260119.110006

// WARNING: generated by kopium - manual changes will be overwritten
// kopium command: kopium --docs --derive=Default --derive=PartialEq --smart-derive-elision --filename crd-catalog/eclipse-che/che-operator/org.eclipse.che/v2/checlusters.yaml
// kopium version: 0.22.5

#[allow(unused_imports)]
mod prelude {
    pub use kube::CustomResource;
    pub use serde::{Serialize, Deserialize};
    pub use std::collections::BTreeMap;
    pub use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
}
use self::prelude::*;

/// Desired configuration of Eclipse Che installation.
#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[kube(group = "org.eclipse.che", version = "v2", kind = "CheCluster", plural = "checlusters")]
#[kube(namespaced)]
#[kube(status = "CheClusterStatus")]
#[kube(schema = "disabled")]
#[kube(derive="Default")]
#[kube(derive="PartialEq")]
pub struct CheClusterSpec {
    /// Che components configuration.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub components: Option<CheClusterComponents>,
    /// Configuration of an alternative registry that stores Che images.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerRegistry")]
    pub container_registry: Option<CheClusterContainerRegistry>,
    /// Development environment default configuration options.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "devEnvironments")]
    pub dev_environments: Option<CheClusterDevEnvironments>,
    /// A configuration that allows users to work with remote Git repositories.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gitServices")]
    pub git_services: Option<CheClusterGitServices>,
    /// Networking, Che authentication, and TLS configuration.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub networking: Option<CheClusterNetworking>,
}

/// Che components configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponents {
    /// General configuration settings related to the Che server.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cheServer")]
    pub che_server: Option<CheClusterComponentsCheServer>,
    /// Configuration settings related to the dashboard used by the Che installation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dashboard: Option<CheClusterComponentsDashboard>,
    /// DevWorkspace Operator configuration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "devWorkspace")]
    pub dev_workspace: Option<CheClusterComponentsDevWorkspace>,
    /// Configuration settings related to the devfile registry used by the Che installation.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "devfileRegistry")]
    pub devfile_registry: Option<CheClusterComponentsDevfileRegistry>,
    /// Kubernetes Image Puller configuration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePuller")]
    pub image_puller: Option<CheClusterComponentsImagePuller>,
    /// Che server metrics configuration.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<CheClusterComponentsMetrics>,
    /// Configuration settings related to the plug-in registry used by the Che installation.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "pluginRegistry")]
    pub plugin_registry: Option<CheClusterComponentsPluginRegistry>,
}

/// General configuration settings related to the Che server.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServer {
    /// Additional ClusterRoles assigned to Che ServiceAccount.
    /// Each role must have a `app.kubernetes.io/part-of=che.eclipse.org` label.
    /// The defaults roles are:
    /// - `<che-namespace>-cheworkspaces-clusterrole`
    /// - `<che-namespace>-cheworkspaces-namespaces-clusterrole`
    /// - `<che-namespace>-cheworkspaces-devworkspace-clusterrole`
    /// where the <che-namespace> is the namespace where the CheCluster CR is created.
    /// The Che Operator must already have all permissions in these ClusterRoles to grant them.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clusterRoles")]
    pub cluster_roles: Option<Vec<String>>,
    /// Enables the debug mode for Che server.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub debug: Option<bool>,
    /// Deployment override options.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deployment: Option<CheClusterComponentsCheServerDeployment>,
    /// A map of additional environment variables applied in the generated `che` ConfigMap to be used by the Che server
    /// in addition to the values already generated from other fields of the `CheCluster` custom resource (CR).
    /// If the `extraProperties` field contains a property normally generated in `che` ConfigMap from other CR fields,
    /// the value defined in the `extraProperties` is used instead.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "extraProperties")]
    pub extra_properties: Option<BTreeMap<String, String>>,
    /// The log level for the Che server: `INFO` or `DEBUG`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logLevel")]
    pub log_level: Option<String>,
    /// Proxy server settings for Kubernetes cluster. No additional configuration is required for OpenShift cluster.
    /// By specifying these settings for the OpenShift cluster, you override the OpenShift proxy configuration.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub proxy: Option<CheClusterComponentsCheServerProxy>,
}

/// Deployment override options.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeployment {
    /// List of containers belonging to the pod.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<CheClusterComponentsCheServerDeploymentContainers>>,
    /// The node selector limits the nodes that can run the pod.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
    pub node_selector: Option<BTreeMap<String, String>>,
    /// Security options the pod should run with.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<CheClusterComponentsCheServerDeploymentSecurityContext>,
    /// The pod tolerations of the component pod limit where the pod can run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tolerations: Option<Vec<CheClusterComponentsCheServerDeploymentTolerations>>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainers {
    /// List of environment variables to set in the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterComponentsCheServerDeploymentContainersEnv>>,
    /// Container image. Omit it or leave it empty to use the default container image provided by the Operator.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// Image pull policy. Default value is `Always` for `nightly`, `next` or `latest` images, and `IfNotPresent` in other cases.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<CheClusterComponentsCheServerDeploymentContainersImagePullPolicy>,
    /// Container name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Compute resources required by this container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<CheClusterComponentsCheServerDeploymentContainersResources>,
}

/// EnvVar represents an environment variable present in a Container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersEnv {
    /// Name of the environment variable.
    /// May consist of any printable ASCII characters except '='.
    pub name: String,
    /// Variable references $(VAR_NAME) are expanded
    /// using the previously defined environment variables in the container and
    /// any service environment variables. If a variable cannot be resolved,
    /// the reference in the input string will be unchanged. Double $$ are reduced
    /// to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.
    /// "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
    /// Escaped references will never be expanded, regardless of whether the variable
    /// exists or not.
    /// Defaults to "".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Source for the environment variable's value. Cannot be used if value is not empty.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
    pub value_from: Option<CheClusterComponentsCheServerDeploymentContainersEnvValueFrom>,
}

/// Source for the environment variable's value. Cannot be used if value is not empty.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersEnvValueFrom {
    /// Selects a key of a ConfigMap.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<CheClusterComponentsCheServerDeploymentContainersEnvValueFromConfigMapKeyRef>,
    /// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
    /// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<CheClusterComponentsCheServerDeploymentContainersEnvValueFromFieldRef>,
    /// FileKeyRef selects a key of the env file.
    /// Requires the EnvFiles feature gate to be enabled.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileKeyRef")]
    pub file_key_ref: Option<CheClusterComponentsCheServerDeploymentContainersEnvValueFromFileKeyRef>,
    /// Selects a resource of the container: only resources limits and requests
    /// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<CheClusterComponentsCheServerDeploymentContainersEnvValueFromResourceFieldRef>,
    /// Selects a key of a secret in the pod's namespace
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<CheClusterComponentsCheServerDeploymentContainersEnvValueFromSecretKeyRef>,
}

/// Selects a key of a ConfigMap.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersEnvValueFromConfigMapKeyRef {
    /// The key to select.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the ConfigMap or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
/// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersEnvValueFromFieldRef {
    /// Version of the schema the FieldPath is written in terms of, defaults to "v1".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    /// Path of the field to select in the specified API version.
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

/// FileKeyRef selects a key of the env file.
/// Requires the EnvFiles feature gate to be enabled.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersEnvValueFromFileKeyRef {
    /// The key within the env file. An invalid key will prevent the pod from starting.
    /// The keys defined within a source may consist of any printable ASCII characters except '='.
    /// During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.
    pub key: String,
    /// Specify whether the file or its key must be defined. If the file or key
    /// does not exist, then the env var is not published.
    /// If optional is set to true and the specified key does not exist,
    /// the environment variable will not be set in the Pod's containers.
    /// 
    /// If optional is set to false and the specified key does not exist,
    /// an error will be returned during Pod creation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
    /// The path within the volume from which to select the file.
    /// Must be relative and may not contain the '..' path or start with '..'.
    pub path: String,
    /// The name of the volume mount containing the env file.
    #[serde(rename = "volumeName")]
    pub volume_name: String,
}

/// Selects a resource of the container: only resources limits and requests
/// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersEnvValueFromResourceFieldRef {
    /// Container name: required for volumes, optional for env vars
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the output format of the exposed resources, defaults to "1"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    /// Required: resource to select
    pub resource: String,
}

/// Selects a key of a secret in the pod's namespace
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersEnvValueFromSecretKeyRef {
    /// The key of the secret to select from.  Must be a valid secret key.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the Secret or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterComponentsCheServerDeploymentContainersImagePullPolicy {
    Always,
    IfNotPresent,
    Never,
}

/// Compute resources required by this container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersResources {
    /// Describes the maximum amount of compute resources allowed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<CheClusterComponentsCheServerDeploymentContainersResourcesLimits>,
    /// Describes the minimum amount of compute resources required.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<CheClusterComponentsCheServerDeploymentContainersResourcesRequest>,
}

/// Describes the maximum amount of compute resources allowed.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersResourcesLimits {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Describes the minimum amount of compute resources required.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentContainersResourcesRequest {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Security options the pod should run with.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentSecurityContext {
    /// A special supplemental group that applies to all containers in a pod. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroup")]
    pub fs_group: Option<i64>,
    /// The UID to run the entrypoint of the container process. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
}

/// The pod this Toleration is attached to tolerates any taint that matches
/// the triple <key,value,effect> using the matching operator <operator>.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerDeploymentTolerations {
    /// Effect indicates the taint effect to match. Empty means match all taint effects.
    /// When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effect: Option<String>,
    /// Key is the taint key that the toleration applies to. Empty means match all taint keys.
    /// If the key is empty, operator must be Exists; this combination means to match all values and all keys.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    /// Operator represents a key's relationship to the value.
    /// Valid operators are Exists and Equal. Defaults to Equal.
    /// Exists is equivalent to wildcard for value, so that a pod can
    /// tolerate all taints of a particular category.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    /// TolerationSeconds represents the period of time the toleration (which must be
    /// of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
    /// it is not set, which means tolerate the taint forever (do not evict). Zero and
    /// negative values will be treated as 0 (evict immediately) by the system.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tolerationSeconds")]
    pub toleration_seconds: Option<i64>,
    /// Value is the taint value the toleration matches to.
    /// If the operator is Exists, the value should be empty, otherwise just a regular string.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// Proxy server settings for Kubernetes cluster. No additional configuration is required for OpenShift cluster.
/// By specifying these settings for the OpenShift cluster, you override the OpenShift proxy configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsCheServerProxy {
    /// The secret name that contains `user` and `password` for a proxy server.
    /// The secret must have a `app.kubernetes.io/part-of=che.eclipse.org` label.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsSecretName")]
    pub credentials_secret_name: Option<String>,
    /// A list of hosts that can be reached directly, bypassing the proxy.
    /// Specify wild card domain use the following form `.<DOMAIN>`, for example:
    ///    - localhost
    ///    - 127.0.0.1
    ///    - my.host.com
    ///    - 123.42.12.32
    /// Use only when a proxy configuration is required. The Operator respects OpenShift cluster-wide proxy configuration,
    /// defining `nonProxyHosts` in a custom resource leads to merging non-proxy hosts lists from the cluster proxy configuration, and the ones defined in the custom resources.
    /// See the following page: <https://docs.openshift.com/container-platform/latest/networking/enable-cluster-wide-proxy.html.>
    /// In some proxy configurations, localhost may not translate to 127.0.0.1. Both localhost and 127.0.0.1 should be specified in this situation.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nonProxyHosts")]
    pub non_proxy_hosts: Option<Vec<String>>,
    /// Proxy server port.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub port: Option<String>,
    /// URL (protocol+hostname) of the proxy server.
    /// Use only when a proxy configuration is required. The Operator respects OpenShift cluster-wide proxy configuration,
    /// defining `url` in a custom resource leads to overriding the cluster proxy configuration.
    /// See the following page: <https://docs.openshift.com/container-platform/latest/networking/enable-cluster-wide-proxy.html.>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// Configuration settings related to the dashboard used by the Che installation.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboard {
    /// Dashboard branding resources.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branding: Option<CheClusterComponentsDashboardBranding>,
    /// Deployment override options.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deployment: Option<CheClusterComponentsDashboardDeployment>,
    /// Dashboard header message.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "headerMessage")]
    pub header_message: Option<CheClusterComponentsDashboardHeaderMessage>,
    /// The log level for the Dashboard.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logLevel")]
    pub log_level: Option<CheClusterComponentsDashboardLogLevel>,
}

/// Dashboard branding resources.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardBranding {
    /// Dashboard logo.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo: Option<CheClusterComponentsDashboardBrandingLogo>,
}

/// Dashboard logo.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardBrandingLogo {
    pub base64data: String,
    pub mediatype: String,
}

/// Deployment override options.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeployment {
    /// List of containers belonging to the pod.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<CheClusterComponentsDashboardDeploymentContainers>>,
    /// The node selector limits the nodes that can run the pod.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
    pub node_selector: Option<BTreeMap<String, String>>,
    /// Security options the pod should run with.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<CheClusterComponentsDashboardDeploymentSecurityContext>,
    /// The pod tolerations of the component pod limit where the pod can run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tolerations: Option<Vec<CheClusterComponentsDashboardDeploymentTolerations>>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainers {
    /// List of environment variables to set in the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterComponentsDashboardDeploymentContainersEnv>>,
    /// Container image. Omit it or leave it empty to use the default container image provided by the Operator.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// Image pull policy. Default value is `Always` for `nightly`, `next` or `latest` images, and `IfNotPresent` in other cases.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<CheClusterComponentsDashboardDeploymentContainersImagePullPolicy>,
    /// Container name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Compute resources required by this container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<CheClusterComponentsDashboardDeploymentContainersResources>,
}

/// EnvVar represents an environment variable present in a Container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersEnv {
    /// Name of the environment variable.
    /// May consist of any printable ASCII characters except '='.
    pub name: String,
    /// Variable references $(VAR_NAME) are expanded
    /// using the previously defined environment variables in the container and
    /// any service environment variables. If a variable cannot be resolved,
    /// the reference in the input string will be unchanged. Double $$ are reduced
    /// to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.
    /// "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
    /// Escaped references will never be expanded, regardless of whether the variable
    /// exists or not.
    /// Defaults to "".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Source for the environment variable's value. Cannot be used if value is not empty.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
    pub value_from: Option<CheClusterComponentsDashboardDeploymentContainersEnvValueFrom>,
}

/// Source for the environment variable's value. Cannot be used if value is not empty.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersEnvValueFrom {
    /// Selects a key of a ConfigMap.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<CheClusterComponentsDashboardDeploymentContainersEnvValueFromConfigMapKeyRef>,
    /// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
    /// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<CheClusterComponentsDashboardDeploymentContainersEnvValueFromFieldRef>,
    /// FileKeyRef selects a key of the env file.
    /// Requires the EnvFiles feature gate to be enabled.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileKeyRef")]
    pub file_key_ref: Option<CheClusterComponentsDashboardDeploymentContainersEnvValueFromFileKeyRef>,
    /// Selects a resource of the container: only resources limits and requests
    /// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<CheClusterComponentsDashboardDeploymentContainersEnvValueFromResourceFieldRef>,
    /// Selects a key of a secret in the pod's namespace
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<CheClusterComponentsDashboardDeploymentContainersEnvValueFromSecretKeyRef>,
}

/// Selects a key of a ConfigMap.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersEnvValueFromConfigMapKeyRef {
    /// The key to select.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the ConfigMap or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
/// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersEnvValueFromFieldRef {
    /// Version of the schema the FieldPath is written in terms of, defaults to "v1".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    /// Path of the field to select in the specified API version.
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

/// FileKeyRef selects a key of the env file.
/// Requires the EnvFiles feature gate to be enabled.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersEnvValueFromFileKeyRef {
    /// The key within the env file. An invalid key will prevent the pod from starting.
    /// The keys defined within a source may consist of any printable ASCII characters except '='.
    /// During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.
    pub key: String,
    /// Specify whether the file or its key must be defined. If the file or key
    /// does not exist, then the env var is not published.
    /// If optional is set to true and the specified key does not exist,
    /// the environment variable will not be set in the Pod's containers.
    /// 
    /// If optional is set to false and the specified key does not exist,
    /// an error will be returned during Pod creation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
    /// The path within the volume from which to select the file.
    /// Must be relative and may not contain the '..' path or start with '..'.
    pub path: String,
    /// The name of the volume mount containing the env file.
    #[serde(rename = "volumeName")]
    pub volume_name: String,
}

/// Selects a resource of the container: only resources limits and requests
/// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersEnvValueFromResourceFieldRef {
    /// Container name: required for volumes, optional for env vars
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the output format of the exposed resources, defaults to "1"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    /// Required: resource to select
    pub resource: String,
}

/// Selects a key of a secret in the pod's namespace
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersEnvValueFromSecretKeyRef {
    /// The key of the secret to select from.  Must be a valid secret key.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the Secret or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterComponentsDashboardDeploymentContainersImagePullPolicy {
    Always,
    IfNotPresent,
    Never,
}

/// Compute resources required by this container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersResources {
    /// Describes the maximum amount of compute resources allowed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<CheClusterComponentsDashboardDeploymentContainersResourcesLimits>,
    /// Describes the minimum amount of compute resources required.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<CheClusterComponentsDashboardDeploymentContainersResourcesRequest>,
}

/// Describes the maximum amount of compute resources allowed.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersResourcesLimits {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Describes the minimum amount of compute resources required.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentContainersResourcesRequest {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Security options the pod should run with.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentSecurityContext {
    /// A special supplemental group that applies to all containers in a pod. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroup")]
    pub fs_group: Option<i64>,
    /// The UID to run the entrypoint of the container process. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
}

/// The pod this Toleration is attached to tolerates any taint that matches
/// the triple <key,value,effect> using the matching operator <operator>.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardDeploymentTolerations {
    /// Effect indicates the taint effect to match. Empty means match all taint effects.
    /// When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effect: Option<String>,
    /// Key is the taint key that the toleration applies to. Empty means match all taint keys.
    /// If the key is empty, operator must be Exists; this combination means to match all values and all keys.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    /// Operator represents a key's relationship to the value.
    /// Valid operators are Exists and Equal. Defaults to Equal.
    /// Exists is equivalent to wildcard for value, so that a pod can
    /// tolerate all taints of a particular category.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    /// TolerationSeconds represents the period of time the toleration (which must be
    /// of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
    /// it is not set, which means tolerate the taint forever (do not evict). Zero and
    /// negative values will be treated as 0 (evict immediately) by the system.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tolerationSeconds")]
    pub toleration_seconds: Option<i64>,
    /// Value is the taint value the toleration matches to.
    /// If the operator is Exists, the value should be empty, otherwise just a regular string.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// Dashboard header message.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDashboardHeaderMessage {
    /// Instructs dashboard to show the message.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub show: Option<bool>,
    /// Warning message displayed on the user dashboard.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
}

/// Configuration settings related to the dashboard used by the Che installation.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterComponentsDashboardLogLevel {
    #[serde(rename = "DEBUG")]
    Debug,
    #[serde(rename = "INFO")]
    Info,
    #[serde(rename = "WARN")]
    Warn,
    #[serde(rename = "ERROR")]
    Error,
    #[serde(rename = "FATAL")]
    Fatal,
    #[serde(rename = "TRACE")]
    Trace,
    #[serde(rename = "SILENT")]
    Silent,
}

/// DevWorkspace Operator configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevWorkspace {
    /// Deprecated in favor of `MaxNumberOfRunningWorkspacesPerUser`
    /// The maximum number of running workspaces per user.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runningLimit")]
    pub running_limit: Option<String>,
}

/// Configuration settings related to the devfile registry used by the Che installation.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistry {
    /// Deprecated deployment override options.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deployment: Option<CheClusterComponentsDevfileRegistryDeployment>,
    /// Disables internal devfile registry.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableInternalRegistry")]
    pub disable_internal_registry: Option<bool>,
    /// External devfile registries serving sample ready-to-use devfiles.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalDevfileRegistries")]
    pub external_devfile_registries: Option<Vec<CheClusterComponentsDevfileRegistryExternalDevfileRegistries>>,
}

/// Deprecated deployment override options.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeployment {
    /// List of containers belonging to the pod.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<CheClusterComponentsDevfileRegistryDeploymentContainers>>,
    /// The node selector limits the nodes that can run the pod.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
    pub node_selector: Option<BTreeMap<String, String>>,
    /// Security options the pod should run with.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<CheClusterComponentsDevfileRegistryDeploymentSecurityContext>,
    /// The pod tolerations of the component pod limit where the pod can run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tolerations: Option<Vec<CheClusterComponentsDevfileRegistryDeploymentTolerations>>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainers {
    /// List of environment variables to set in the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterComponentsDevfileRegistryDeploymentContainersEnv>>,
    /// Container image. Omit it or leave it empty to use the default container image provided by the Operator.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// Image pull policy. Default value is `Always` for `nightly`, `next` or `latest` images, and `IfNotPresent` in other cases.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<CheClusterComponentsDevfileRegistryDeploymentContainersImagePullPolicy>,
    /// Container name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Compute resources required by this container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<CheClusterComponentsDevfileRegistryDeploymentContainersResources>,
}

/// EnvVar represents an environment variable present in a Container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersEnv {
    /// Name of the environment variable.
    /// May consist of any printable ASCII characters except '='.
    pub name: String,
    /// Variable references $(VAR_NAME) are expanded
    /// using the previously defined environment variables in the container and
    /// any service environment variables. If a variable cannot be resolved,
    /// the reference in the input string will be unchanged. Double $$ are reduced
    /// to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.
    /// "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
    /// Escaped references will never be expanded, regardless of whether the variable
    /// exists or not.
    /// Defaults to "".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Source for the environment variable's value. Cannot be used if value is not empty.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
    pub value_from: Option<CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFrom>,
}

/// Source for the environment variable's value. Cannot be used if value is not empty.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFrom {
    /// Selects a key of a ConfigMap.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromConfigMapKeyRef>,
    /// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
    /// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromFieldRef>,
    /// FileKeyRef selects a key of the env file.
    /// Requires the EnvFiles feature gate to be enabled.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileKeyRef")]
    pub file_key_ref: Option<CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromFileKeyRef>,
    /// Selects a resource of the container: only resources limits and requests
    /// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromResourceFieldRef>,
    /// Selects a key of a secret in the pod's namespace
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromSecretKeyRef>,
}

/// Selects a key of a ConfigMap.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromConfigMapKeyRef {
    /// The key to select.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the ConfigMap or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
/// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromFieldRef {
    /// Version of the schema the FieldPath is written in terms of, defaults to "v1".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    /// Path of the field to select in the specified API version.
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

/// FileKeyRef selects a key of the env file.
/// Requires the EnvFiles feature gate to be enabled.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromFileKeyRef {
    /// The key within the env file. An invalid key will prevent the pod from starting.
    /// The keys defined within a source may consist of any printable ASCII characters except '='.
    /// During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.
    pub key: String,
    /// Specify whether the file or its key must be defined. If the file or key
    /// does not exist, then the env var is not published.
    /// If optional is set to true and the specified key does not exist,
    /// the environment variable will not be set in the Pod's containers.
    /// 
    /// If optional is set to false and the specified key does not exist,
    /// an error will be returned during Pod creation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
    /// The path within the volume from which to select the file.
    /// Must be relative and may not contain the '..' path or start with '..'.
    pub path: String,
    /// The name of the volume mount containing the env file.
    #[serde(rename = "volumeName")]
    pub volume_name: String,
}

/// Selects a resource of the container: only resources limits and requests
/// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromResourceFieldRef {
    /// Container name: required for volumes, optional for env vars
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the output format of the exposed resources, defaults to "1"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    /// Required: resource to select
    pub resource: String,
}

/// Selects a key of a secret in the pod's namespace
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersEnvValueFromSecretKeyRef {
    /// The key of the secret to select from.  Must be a valid secret key.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the Secret or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterComponentsDevfileRegistryDeploymentContainersImagePullPolicy {
    Always,
    IfNotPresent,
    Never,
}

/// Compute resources required by this container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersResources {
    /// Describes the maximum amount of compute resources allowed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<CheClusterComponentsDevfileRegistryDeploymentContainersResourcesLimits>,
    /// Describes the minimum amount of compute resources required.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<CheClusterComponentsDevfileRegistryDeploymentContainersResourcesRequest>,
}

/// Describes the maximum amount of compute resources allowed.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersResourcesLimits {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Describes the minimum amount of compute resources required.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentContainersResourcesRequest {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Security options the pod should run with.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentSecurityContext {
    /// A special supplemental group that applies to all containers in a pod. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroup")]
    pub fs_group: Option<i64>,
    /// The UID to run the entrypoint of the container process. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
}

/// The pod this Toleration is attached to tolerates any taint that matches
/// the triple <key,value,effect> using the matching operator <operator>.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryDeploymentTolerations {
    /// Effect indicates the taint effect to match. Empty means match all taint effects.
    /// When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effect: Option<String>,
    /// Key is the taint key that the toleration applies to. Empty means match all taint keys.
    /// If the key is empty, operator must be Exists; this combination means to match all values and all keys.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    /// Operator represents a key's relationship to the value.
    /// Valid operators are Exists and Equal. Defaults to Equal.
    /// Exists is equivalent to wildcard for value, so that a pod can
    /// tolerate all taints of a particular category.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    /// TolerationSeconds represents the period of time the toleration (which must be
    /// of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
    /// it is not set, which means tolerate the taint forever (do not evict). Zero and
    /// negative values will be treated as 0 (evict immediately) by the system.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tolerationSeconds")]
    pub toleration_seconds: Option<i64>,
    /// Value is the taint value the toleration matches to.
    /// If the operator is Exists, the value should be empty, otherwise just a regular string.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// External devfile registries configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsDevfileRegistryExternalDevfileRegistries {
    /// The public URL of the devfile registry that serves sample ready-to-use devfiles.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// Kubernetes Image Puller configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsImagePuller {
    /// Install and configure the community supported Kubernetes Image Puller Operator. When you set the value to `true` without providing any specs,
    /// it creates a default Kubernetes Image Puller object managed by the Operator.
    /// When you set the value to `false`, the Kubernetes Image Puller object is deleted, and the Operator uninstalled,
    /// regardless of whether a spec is provided.
    /// If you leave the `spec.images` field empty, a set of recommended workspace-related images is automatically detected and
    /// pre-pulled after installation.
    /// Note that while this Operator and its behavior is community-supported, its payload may be commercially-supported
    /// for pulling commercially-supported images.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enable: Option<bool>,
    /// A Kubernetes Image Puller spec to configure the image puller in the CheCluster.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spec: Option<CheClusterComponentsImagePullerSpec>,
}

/// A Kubernetes Image Puller spec to configure the image puller in the CheCluster.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsImagePullerSpec {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub affinity: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cachingCPULimit")]
    pub caching_cpu_limit: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cachingCPURequest")]
    pub caching_cpu_request: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cachingIntervalHours")]
    pub caching_interval_hours: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cachingMemoryLimit")]
    pub caching_memory_limit: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cachingMemoryRequest")]
    pub caching_memory_request: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapName")]
    pub config_map_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "daemonsetName")]
    pub daemonset_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "deploymentName")]
    pub deployment_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullSecrets")]
    pub image_pull_secrets: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullerImage")]
    pub image_puller_image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub images: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
    pub node_selector: Option<String>,
}

/// Che server metrics configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsMetrics {
    /// Enables `metrics` for the Che server endpoint.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enable: Option<bool>,
}

/// Configuration settings related to the plug-in registry used by the Che installation.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistry {
    /// Deployment override options.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deployment: Option<CheClusterComponentsPluginRegistryDeployment>,
    /// Disables internal plug-in registry.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableInternalRegistry")]
    pub disable_internal_registry: Option<bool>,
    /// External plugin registries.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalPluginRegistries")]
    pub external_plugin_registries: Option<Vec<CheClusterComponentsPluginRegistryExternalPluginRegistries>>,
    /// Open VSX registry URL. If omitted an embedded instance will be used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "openVSXURL")]
    pub open_vsxurl: Option<String>,
}

/// Deployment override options.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeployment {
    /// List of containers belonging to the pod.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<CheClusterComponentsPluginRegistryDeploymentContainers>>,
    /// The node selector limits the nodes that can run the pod.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
    pub node_selector: Option<BTreeMap<String, String>>,
    /// Security options the pod should run with.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<CheClusterComponentsPluginRegistryDeploymentSecurityContext>,
    /// The pod tolerations of the component pod limit where the pod can run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tolerations: Option<Vec<CheClusterComponentsPluginRegistryDeploymentTolerations>>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainers {
    /// List of environment variables to set in the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterComponentsPluginRegistryDeploymentContainersEnv>>,
    /// Container image. Omit it or leave it empty to use the default container image provided by the Operator.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// Image pull policy. Default value is `Always` for `nightly`, `next` or `latest` images, and `IfNotPresent` in other cases.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<CheClusterComponentsPluginRegistryDeploymentContainersImagePullPolicy>,
    /// Container name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Compute resources required by this container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<CheClusterComponentsPluginRegistryDeploymentContainersResources>,
}

/// EnvVar represents an environment variable present in a Container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersEnv {
    /// Name of the environment variable.
    /// May consist of any printable ASCII characters except '='.
    pub name: String,
    /// Variable references $(VAR_NAME) are expanded
    /// using the previously defined environment variables in the container and
    /// any service environment variables. If a variable cannot be resolved,
    /// the reference in the input string will be unchanged. Double $$ are reduced
    /// to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.
    /// "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
    /// Escaped references will never be expanded, regardless of whether the variable
    /// exists or not.
    /// Defaults to "".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Source for the environment variable's value. Cannot be used if value is not empty.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
    pub value_from: Option<CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFrom>,
}

/// Source for the environment variable's value. Cannot be used if value is not empty.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFrom {
    /// Selects a key of a ConfigMap.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromConfigMapKeyRef>,
    /// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
    /// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromFieldRef>,
    /// FileKeyRef selects a key of the env file.
    /// Requires the EnvFiles feature gate to be enabled.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileKeyRef")]
    pub file_key_ref: Option<CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromFileKeyRef>,
    /// Selects a resource of the container: only resources limits and requests
    /// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromResourceFieldRef>,
    /// Selects a key of a secret in the pod's namespace
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromSecretKeyRef>,
}

/// Selects a key of a ConfigMap.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromConfigMapKeyRef {
    /// The key to select.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the ConfigMap or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
/// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromFieldRef {
    /// Version of the schema the FieldPath is written in terms of, defaults to "v1".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    /// Path of the field to select in the specified API version.
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

/// FileKeyRef selects a key of the env file.
/// Requires the EnvFiles feature gate to be enabled.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromFileKeyRef {
    /// The key within the env file. An invalid key will prevent the pod from starting.
    /// The keys defined within a source may consist of any printable ASCII characters except '='.
    /// During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.
    pub key: String,
    /// Specify whether the file or its key must be defined. If the file or key
    /// does not exist, then the env var is not published.
    /// If optional is set to true and the specified key does not exist,
    /// the environment variable will not be set in the Pod's containers.
    /// 
    /// If optional is set to false and the specified key does not exist,
    /// an error will be returned during Pod creation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
    /// The path within the volume from which to select the file.
    /// Must be relative and may not contain the '..' path or start with '..'.
    pub path: String,
    /// The name of the volume mount containing the env file.
    #[serde(rename = "volumeName")]
    pub volume_name: String,
}

/// Selects a resource of the container: only resources limits and requests
/// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromResourceFieldRef {
    /// Container name: required for volumes, optional for env vars
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the output format of the exposed resources, defaults to "1"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    /// Required: resource to select
    pub resource: String,
}

/// Selects a key of a secret in the pod's namespace
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersEnvValueFromSecretKeyRef {
    /// The key of the secret to select from.  Must be a valid secret key.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the Secret or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterComponentsPluginRegistryDeploymentContainersImagePullPolicy {
    Always,
    IfNotPresent,
    Never,
}

/// Compute resources required by this container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersResources {
    /// Describes the maximum amount of compute resources allowed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<CheClusterComponentsPluginRegistryDeploymentContainersResourcesLimits>,
    /// Describes the minimum amount of compute resources required.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<CheClusterComponentsPluginRegistryDeploymentContainersResourcesRequest>,
}

/// Describes the maximum amount of compute resources allowed.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersResourcesLimits {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Describes the minimum amount of compute resources required.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentContainersResourcesRequest {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Security options the pod should run with.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentSecurityContext {
    /// A special supplemental group that applies to all containers in a pod. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroup")]
    pub fs_group: Option<i64>,
    /// The UID to run the entrypoint of the container process. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
}

/// The pod this Toleration is attached to tolerates any taint that matches
/// the triple <key,value,effect> using the matching operator <operator>.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryDeploymentTolerations {
    /// Effect indicates the taint effect to match. Empty means match all taint effects.
    /// When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effect: Option<String>,
    /// Key is the taint key that the toleration applies to. Empty means match all taint keys.
    /// If the key is empty, operator must be Exists; this combination means to match all values and all keys.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    /// Operator represents a key's relationship to the value.
    /// Valid operators are Exists and Equal. Defaults to Equal.
    /// Exists is equivalent to wildcard for value, so that a pod can
    /// tolerate all taints of a particular category.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    /// TolerationSeconds represents the period of time the toleration (which must be
    /// of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
    /// it is not set, which means tolerate the taint forever (do not evict). Zero and
    /// negative values will be treated as 0 (evict immediately) by the system.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tolerationSeconds")]
    pub toleration_seconds: Option<i64>,
    /// Value is the taint value the toleration matches to.
    /// If the operator is Exists, the value should be empty, otherwise just a regular string.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// External plug-in registries configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterComponentsPluginRegistryExternalPluginRegistries {
    /// Public URL of the plug-in registry.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// Configuration of an alternative registry that stores Che images.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterContainerRegistry {
    /// An optional hostname or URL of an alternative container registry to pull images from.
    /// This value overrides the container registry hostname defined in all the default container images involved in a Che deployment.
    /// This is particularly useful for installing Che in a restricted environment.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hostname: Option<String>,
    /// An optional repository name of an alternative registry to pull images from.
    /// This value overrides the container registry organization defined in all the default container images involved in a Che deployment.
    /// This is particularly useful for installing Eclipse Che in a restricted environment.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub organization: Option<String>,
}

/// Development environment default configuration options.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironments {
    /// AllowedSources defines the allowed sources on which workspaces can be started.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowedSources")]
    pub allowed_sources: Option<CheClusterDevEnvironmentsAllowedSources>,
    /// Container build configuration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerBuildConfiguration")]
    pub container_build_configuration: Option<CheClusterDevEnvironmentsContainerBuildConfiguration>,
    /// ContainerResourceCaps defines the maximum resource requirements enforced for workspace
    /// containers. If a container specifies limits or requests that exceed these values, they
    /// will be capped at the maximum. Note: Caps only apply when resources are already specified
    /// on a container. For containers without resource specifications, use DefaultContainerResources
    /// instead. These resource caps do not apply to initContainers or the projectClone container.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerResourceCaps")]
    pub container_resource_caps: Option<CheClusterDevEnvironmentsContainerResourceCaps>,
    /// Container run configuration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerRunConfiguration")]
    pub container_run_configuration: Option<CheClusterDevEnvironmentsContainerRunConfiguration>,
    /// Default components applied to DevWorkspaces.
    /// These default components are meant to be used when a Devfile, that does not contain any components.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultComponents")]
    pub default_components: Option<Vec<CheClusterDevEnvironmentsDefaultComponents>>,
    /// DefaultContainerResources defines the resource requirements (memory/cpu limit/request) used for
    /// container components that do not define limits or requests.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultContainerResources")]
    pub default_container_resources: Option<CheClusterDevEnvironmentsDefaultContainerResources>,
    /// The default editor to workspace create with. It could be a plugin ID or a URI.
    /// The plugin ID must have `publisher/name/version` format.
    /// The URI must start from `<http://`> or `<https://`.>
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultEditor")]
    pub default_editor: Option<String>,
    /// User's default namespace.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultNamespace")]
    pub default_namespace: Option<CheClusterDevEnvironmentsDefaultNamespace>,
    /// Default plug-ins applied to DevWorkspaces.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultPlugins")]
    pub default_plugins: Option<Vec<CheClusterDevEnvironmentsDefaultPlugins>>,
    /// DeploymentStrategy defines the deployment strategy to use to replace existing workspace pods
    /// with new ones. The available deployment stragies are `Recreate` and `RollingUpdate`.
    /// With the `Recreate` deployment strategy, the existing workspace pod is killed before the new one is created.
    /// With the `RollingUpdate` deployment strategy, a new workspace pod is created and the existing workspace pod is deleted
    /// only when the new workspace pod is in a ready state.
    /// If not specified, the default `Recreate` deployment strategy is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "deploymentStrategy")]
    pub deployment_strategy: Option<CheClusterDevEnvironmentsDeploymentStrategy>,
    /// Disables the container build capabilities.
    /// When set to `false` (the default value), the devEnvironments.security.containerSecurityContext
    /// field is ignored, and the following container SecurityContext is applied:
    /// 
    ///  containerSecurityContext:
    ///    allowPrivilegeEscalation: true
    ///    capabilities:
    ///      add:
    ///      - SETGID
    ///      - SETUID
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableContainerBuildCapabilities")]
    pub disable_container_build_capabilities: Option<bool>,
    /// Disables container run capabilities.
    /// Can be enabled on OpenShift version 4.20 or later.
    /// When set to `false`, the value from `devEnvironments.security.containerSecurityContext`
    /// is ignored, and instead the SecurityContext defined in
    /// `devEnvironments.containerRunConfiguration.containerSecurityContext` is applied.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableContainerRunCapabilities")]
    pub disable_container_run_capabilities: Option<bool>,
    /// EditorsDownloadUrls provides a list of custom download URLs for JetBrains editors
    /// in a local-to-remote flow.
    /// It is particularly useful in disconnected or air-gapped environments,
    /// where editors cannot be downloaded from the public internet.
    /// Each entry contains an editor identifier in the `publisher/name/version` format
    /// and the corresponding download URL.
    /// Currently, this field is intended only for JetBrains editors and should not be used for other editor types.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "editorsDownloadUrls")]
    pub editors_download_urls: Option<Vec<CheClusterDevEnvironmentsEditorsDownloadUrls>>,
    /// GatewayContainer configuration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gatewayContainer")]
    pub gateway_container: Option<CheClusterDevEnvironmentsGatewayContainer>,
    /// IgnoredUnrecoverableEvents defines a list of Kubernetes event names that should
    /// be ignored when deciding to fail a workspace that is starting. This option should be used
    /// if a transient cluster issue is triggering false-positives (for example, if
    /// the cluster occasionally encounters FailedScheduling events). Events listed
    /// here will not trigger workspace failures.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ignoredUnrecoverableEvents")]
    pub ignored_unrecoverable_events: Option<Vec<String>>,
    /// ImagePullPolicy defines the imagePullPolicy used for containers in a DevWorkspace.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<CheClusterDevEnvironmentsImagePullPolicy>,
    /// The maximum number of concurrently running workspaces across the entire Kubernetes cluster.
    /// This applies to all users in the system. If the value is set to -1, it means there is
    /// no limit on the number of running workspaces.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxNumberOfRunningWorkspacesPerCluster")]
    pub max_number_of_running_workspaces_per_cluster: Option<i64>,
    /// The maximum number of running workspaces per user.
    /// The value, -1, allows users to run an unlimited number of workspaces.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxNumberOfRunningWorkspacesPerUser")]
    pub max_number_of_running_workspaces_per_user: Option<i64>,
    /// Total number of workspaces, both stopped and running, that a user can keep.
    /// The value, -1, allows users to keep an unlimited number of workspaces.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxNumberOfWorkspacesPerUser")]
    pub max_number_of_workspaces_per_user: Option<i64>,
    /// Configuration settings related to the workspaces networking.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub networking: Option<CheClusterDevEnvironmentsNetworking>,
    /// The node selector limits the nodes that can run the workspace pods.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
    pub node_selector: Option<BTreeMap<String, String>>,
    /// PersistUserHome defines configuration options for persisting the
    /// user home directory in workspaces.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "persistUserHome")]
    pub persist_user_home: Option<CheClusterDevEnvironmentsPersistUserHome>,
    /// Pod scheduler for the workspace pods.
    /// If not specified, the pod scheduler is set to the default scheduler on the cluster.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podSchedulerName")]
    pub pod_scheduler_name: Option<String>,
    /// Project clone container configuration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "projectCloneContainer")]
    pub project_clone_container: Option<CheClusterDevEnvironmentsProjectCloneContainer>,
    /// RuntimeClassName specifies the spec.runtimeClassName for workspace pods.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runtimeClassName")]
    pub runtime_class_name: Option<String>,
    /// Idle timeout for workspaces in seconds.
    /// This timeout is the duration after which a workspace will be idled if there is no activity.
    /// To disable workspace idling due to inactivity, set this value to -1.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secondsOfInactivityBeforeIdling")]
    pub seconds_of_inactivity_before_idling: Option<i32>,
    /// Run timeout for workspaces in seconds.
    /// This timeout is the maximum duration a workspace runs.
    /// To disable workspace run timeout, set this value to -1.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secondsOfRunBeforeIdling")]
    pub seconds_of_run_before_idling: Option<i32>,
    /// Workspace security configuration.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub security: Option<CheClusterDevEnvironmentsSecurity>,
    /// ServiceAccount to use by the DevWorkspace operator when starting the workspaces.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAccount")]
    pub service_account: Option<String>,
    /// List of ServiceAccount tokens that will be mounted into workspace pods as projected volumes.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAccountTokens")]
    pub service_account_tokens: Option<Vec<CheClusterDevEnvironmentsServiceAccountTokens>>,
    /// StartTimeoutSeconds determines the maximum duration (in seconds) that a workspace can take to start
    /// before it is automatically failed.
    /// If not specified, the default value of 300 seconds (5 minutes) is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "startTimeoutSeconds")]
    pub start_timeout_seconds: Option<i32>,
    /// Workspaces persistent storage.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<CheClusterDevEnvironmentsStorage>,
    /// The pod tolerations of the workspace pods limit where the workspace pods can run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tolerations: Option<Vec<CheClusterDevEnvironmentsTolerations>>,
    /// Trusted certificate settings.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "trustedCerts")]
    pub trusted_certs: Option<CheClusterDevEnvironmentsTrustedCerts>,
    /// User configuration.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<CheClusterDevEnvironmentsUser>,
    /// WorkspacesPodAnnotations defines additional annotations for workspace pods.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "workspacesPodAnnotations")]
    pub workspaces_pod_annotations: Option<BTreeMap<String, String>>,
}

/// AllowedSources defines the allowed sources on which workspaces can be started.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsAllowedSources {
    /// The list of approved URLs for starting Cloud Development Environments (CDEs). CDEs can only be
    /// initiated from these URLs. Wildcards `*` are supported in URLs, allowing flexible matching for
    /// specific URL patterns. For instance, `<https://example.com/*`> would allow CDEs to be initiated
    /// from any path within 'example.com'.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub urls: Option<Vec<String>>,
}

/// Container build configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerBuildConfiguration {
    /// OpenShift security context constraint to build containers.
    #[serde(rename = "openShiftSecurityContextConstraint")]
    pub open_shift_security_context_constraint: String,
}

/// ContainerResourceCaps defines the maximum resource requirements enforced for workspace
/// containers. If a container specifies limits or requests that exceed these values, they
/// will be capped at the maximum. Note: Caps only apply when resources are already specified
/// on a container. For containers without resource specifications, use DefaultContainerResources
/// instead. These resource caps do not apply to initContainers or the projectClone container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerResourceCaps {
    /// Claims lists the names of resources, defined in spec.resourceClaims,
    /// that are used by this container.
    /// 
    /// This field depends on the
    /// DynamicResourceAllocation feature gate.
    /// 
    /// This field is immutable. It can only be set for containers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<CheClusterDevEnvironmentsContainerResourceCapsClaims>>,
    /// Limits describes the maximum amount of compute resources allowed.
    /// More info: <https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<BTreeMap<String, IntOrString>>,
    /// Requests describes the minimum amount of compute resources required.
    /// If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
    /// otherwise to an implementation-defined value. Requests cannot exceed Limits.
    /// More info: <https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests: Option<BTreeMap<String, IntOrString>>,
}

/// ResourceClaim references one entry in PodSpec.ResourceClaims.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerResourceCapsClaims {
    /// Name must match the name of one entry in pod.spec.resourceClaims of
    /// the Pod where this field is used. It makes that resource available
    /// inside a container.
    pub name: String,
    /// Request is the name chosen for a request in the referenced claim.
    /// If empty, everything from the claim is made available, otherwise
    /// only the result of this request.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<String>,
}

/// Container run configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerRunConfiguration {
    /// SecurityContext applied to all workspace containers when run capabilities are enabled.
    /// The default `procMount: "Unmasked"` is set because the pod runs in a user namespace,
    /// which safely isolates the container's `/proc` from the host. This allows the container
    /// to modify its own sysctl settings for configuring networking for nested containers.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerSecurityContext")]
    pub container_security_context: Option<CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContext>,
    /// Specifies the OpenShift SecurityContextConstraint used to run containers.
    #[serde(rename = "openShiftSecurityContextConstraint")]
    pub open_shift_security_context_constraint: String,
    /// Extra annotations applied to all workspace pods, in addition to those defined
    /// in `devEnvironments.workspacePodAnnotations`. Enables `/dev/fuse` for access to the fuse driver
    /// and `/dev/net/tun` for safe network access.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "workspacesPodAnnotations")]
    pub workspaces_pod_annotations: Option<BTreeMap<String, String>>,
}

/// SecurityContext applied to all workspace containers when run capabilities are enabled.
/// The default `procMount: "Unmasked"` is set because the pod runs in a user namespace,
/// which safely isolates the container's `/proc` from the host. This allows the container
/// to modify its own sysctl settings for configuring networking for nested containers.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContext {
    /// AllowPrivilegeEscalation controls whether a process can gain more
    /// privileges than its parent process. This bool directly controls if
    /// the no_new_privs flag will be set on the container process.
    /// AllowPrivilegeEscalation is true always when the container is:
    /// 1) run as Privileged
    /// 2) has CAP_SYS_ADMIN
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowPrivilegeEscalation")]
    pub allow_privilege_escalation: Option<bool>,
    /// appArmorProfile is the AppArmor options to use by this container. If set, this profile
    /// overrides the pod's appArmorProfile.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "appArmorProfile")]
    pub app_armor_profile: Option<CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextAppArmorProfile>,
    /// The capabilities to add/drop when running containers.
    /// Defaults to the default set of capabilities granted by the container runtime.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextCapabilities>,
    /// Run container in privileged mode.
    /// Processes in privileged containers are essentially equivalent to root on the host.
    /// Defaults to false.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub privileged: Option<bool>,
    /// procMount denotes the type of proc mount to use for the containers.
    /// The default value is Default which uses the container runtime defaults for
    /// readonly paths and masked paths.
    /// This requires the ProcMountType feature flag to be enabled.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "procMount")]
    pub proc_mount: Option<String>,
    /// Whether this container has a read-only root filesystem.
    /// Default is false.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnlyRootFilesystem")]
    pub read_only_root_filesystem: Option<bool>,
    /// The GID to run the entrypoint of the container process.
    /// Uses runtime default if unset.
    /// May also be set in PodSecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
    pub run_as_group: Option<i64>,
    /// Indicates that the container must run as a non-root user.
    /// If true, the Kubelet will validate the image at runtime to ensure that it
    /// does not run as UID 0 (root) and fail to start the container if it does.
    /// If unset or false, no such validation will be performed.
    /// May also be set in PodSecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
    pub run_as_non_root: Option<bool>,
    /// The UID to run the entrypoint of the container process.
    /// Defaults to user specified in image metadata if unspecified.
    /// May also be set in PodSecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
    /// The SELinux context to be applied to the container.
    /// If unspecified, the container runtime will allocate a random SELinux context for each
    /// container.  May also be set in PodSecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
    pub se_linux_options: Option<CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextSeLinuxOptions>,
    /// The seccomp options to use by this container. If seccomp options are
    /// provided at both the pod & container level, the container options
    /// override the pod options.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
    pub seccomp_profile: Option<CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextSeccompProfile>,
    /// The Windows specific settings applied to all containers.
    /// If unspecified, the options from the PodSecurityContext will be used.
    /// If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is linux.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
    pub windows_options: Option<CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextWindowsOptions>,
}

/// appArmorProfile is the AppArmor options to use by this container. If set, this profile
/// overrides the pod's appArmorProfile.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextAppArmorProfile {
    /// localhostProfile indicates a profile loaded on the node that should be used.
    /// The profile must be preconfigured on the node to work.
    /// Must match the loaded name of the profile.
    /// Must be set if and only if type is "Localhost".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
    pub localhost_profile: Option<String>,
    /// type indicates which kind of AppArmor profile will be applied.
    /// Valid options are:
    ///   Localhost - a profile pre-loaded on the node.
    ///   RuntimeDefault - the container runtime's default profile.
    ///   Unconfined - no AppArmor enforcement.
    #[serde(rename = "type")]
    pub r#type: String,
}

/// The capabilities to add/drop when running containers.
/// Defaults to the default set of capabilities granted by the container runtime.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextCapabilities {
    /// Added capabilities
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub add: Option<Vec<String>>,
    /// Removed capabilities
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub drop: Option<Vec<String>>,
}

/// The SELinux context to be applied to the container.
/// If unspecified, the container runtime will allocate a random SELinux context for each
/// container.  May also be set in PodSecurityContext.  If set in both SecurityContext and
/// PodSecurityContext, the value specified in SecurityContext takes precedence.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextSeLinuxOptions {
    /// Level is SELinux level label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub level: Option<String>,
    /// Role is a SELinux role label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    /// Type is a SELinux type label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<String>,
    /// User is a SELinux user label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

/// The seccomp options to use by this container. If seccomp options are
/// provided at both the pod & container level, the container options
/// override the pod options.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextSeccompProfile {
    /// localhostProfile indicates a profile defined in a file on the node should be used.
    /// The profile must be preconfigured on the node to work.
    /// Must be a descending path, relative to the kubelet's configured seccomp profile location.
    /// Must be set if type is "Localhost". Must NOT be set for any other type.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
    pub localhost_profile: Option<String>,
    /// type indicates which kind of seccomp profile will be applied.
    /// Valid options are:
    /// 
    /// Localhost - a profile defined in a file on the node should be used.
    /// RuntimeDefault - the container runtime default profile should be used.
    /// Unconfined - no profile should be applied.
    #[serde(rename = "type")]
    pub r#type: String,
}

/// The Windows specific settings applied to all containers.
/// If unspecified, the options from the PodSecurityContext will be used.
/// If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.
/// Note that this field cannot be set when spec.os.name is linux.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsContainerRunConfigurationContainerSecurityContextWindowsOptions {
    /// GMSACredentialSpec is where the GMSA admission webhook
    /// (<https://github.com/kubernetes-sigs/windows-gmsa)> inlines the contents of the
    /// GMSA credential spec named by the GMSACredentialSpecName field.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
    pub gmsa_credential_spec: Option<String>,
    /// GMSACredentialSpecName is the name of the GMSA credential spec to use.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
    pub gmsa_credential_spec_name: Option<String>,
    /// HostProcess determines if a container should be run as a 'Host Process' container.
    /// All of a Pod's containers must have the same effective HostProcess value
    /// (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers).
    /// In addition, if HostProcess is true then HostNetwork must also be set to true.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
    pub host_process: Option<bool>,
    /// The UserName in Windows to run the entrypoint of the container process.
    /// Defaults to the user specified in image metadata if unspecified.
    /// May also be set in PodSecurityContext. If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
    pub run_as_user_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponents {
    /// Map of implementation-dependant free-form YAML attributes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Type of component
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "componentType")]
    pub component_type: Option<CheClusterDevEnvironmentsDefaultComponentsComponentType>,
    /// Allows adding and configuring devworkspace-related containers
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub container: Option<CheClusterDevEnvironmentsDefaultComponentsContainer>,
    /// Custom component whose logic is implementation-dependant
    /// and should be provided by the user
    /// possibly through some dedicated controller
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom: Option<CheClusterDevEnvironmentsDefaultComponentsCustom>,
    /// Allows specifying the definition of an image for outer loop builds
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<CheClusterDevEnvironmentsDefaultComponentsImage>,
    /// Allows importing into the devworkspace the Kubernetes resources
    /// defined in a given manifest. For example this allows reusing the Kubernetes
    /// definitions used to deploy some runtime components in production.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kubernetes: Option<CheClusterDevEnvironmentsDefaultComponentsKubernetes>,
    /// Mandatory name that allows referencing the component
    /// from other elements (such as commands) or from an external
    /// devfile that may reference this component through a parent or a plugin.
    pub name: String,
    /// Allows importing into the devworkspace the OpenShift resources
    /// defined in a given manifest. For example this allows reusing the OpenShift
    /// definitions used to deploy some runtime components in production.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub openshift: Option<CheClusterDevEnvironmentsDefaultComponentsOpenshift>,
    /// Allows importing a plugin.
    /// 
    /// Plugins are mainly imported devfiles that contribute components, commands
    /// and events as a consistent single unit. They are defined in either YAML files
    /// following the devfile syntax,
    /// or as `DevWorkspaceTemplate` Kubernetes Custom Resources
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plugin: Option<CheClusterDevEnvironmentsDefaultComponentsPlugin>,
    /// Allows specifying the definition of a volume
    /// shared by several other components
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub volume: Option<CheClusterDevEnvironmentsDefaultComponentsVolume>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsComponentType {
    Container,
    Kubernetes,
    Openshift,
    Volume,
    Image,
    Plugin,
    Custom,
}

/// Allows adding and configuring devworkspace-related containers
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsContainer {
    /// Annotations that should be added to specific resources for this container
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotation: Option<CheClusterDevEnvironmentsDefaultComponentsContainerAnnotation>,
    /// The arguments to supply to the command running the dockerimage component. The arguments are supplied either to the default command provided in the image or to the overridden command.
    /// 
    /// Defaults to an empty array, meaning use whatever is defined in the image.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// The command to run in the dockerimage component instead of the default one provided in the image.
    /// 
    /// Defaults to an empty array, meaning use whatever is defined in the image.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cpuLimit")]
    pub cpu_limit: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cpuRequest")]
    pub cpu_request: Option<String>,
    /// Specify if a container should run in its own separated pod,
    /// instead of running as part of the main development environment pod.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dedicatedPod")]
    pub dedicated_pod: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoints: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsContainerEndpoints>>,
    /// Environment variables used in this container.
    /// 
    /// The following variables are reserved and cannot be overridden via env:
    /// 
    ///  - `$PROJECTS_ROOT`
    /// 
    ///  - `$PROJECT_SOURCE`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsContainerEnv>>,
    pub image: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "memoryLimit")]
    pub memory_limit: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "memoryRequest")]
    pub memory_request: Option<String>,
    /// Toggles whether or not the project source code should
    /// be mounted in the component.
    /// 
    /// Defaults to true for all component types except plugins and components that set `dedicatedPod` to true.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "mountSources")]
    pub mount_sources: Option<bool>,
    /// Optional specification of the path in the container where
    /// project sources should be transferred/mounted when `mountSources` is `true`.
    /// When omitted, the default value of /projects is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sourceMapping")]
    pub source_mapping: Option<String>,
    /// List of volumes mounts that should be mounted is this container.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
    pub volume_mounts: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsContainerVolumeMounts>>,
}

/// Annotations that should be added to specific resources for this container
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsContainerAnnotation {
    /// Annotations to be added to deployment
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deployment: Option<BTreeMap<String, String>>,
    /// Annotations to be added to service
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub service: Option<BTreeMap<String, String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsContainerEndpoints {
    /// Annotations to be added to Kubernetes Ingress or Openshift Route
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotation: Option<BTreeMap<String, String>>,
    /// Map of implementation-dependant string-based free-form attributes.
    /// 
    /// Examples of Che-specific attributes:
    /// 
    /// - cookiesAuthEnabled: "true" / "false",
    /// 
    /// - type: "terminal" / "ide" / "ide-dev",
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Describes how the endpoint should be exposed on the network.
    /// 
    /// - `public` means that the endpoint will be exposed on the public network, typically through
    /// a K8S ingress or an OpenShift route.
    /// 
    /// - `internal` means that the endpoint will be exposed internally outside of the main devworkspace POD,
    /// typically by K8S services, to be consumed by other elements running
    /// on the same cloud internal network.
    /// 
    /// - `none` means that the endpoint will not be exposed and will only be accessible
    /// inside the main devworkspace POD, on a local address.
    /// 
    /// Default value is `public`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exposure: Option<CheClusterDevEnvironmentsDefaultComponentsContainerEndpointsExposure>,
    pub name: String,
    /// Path of the endpoint URL
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// Describes the application and transport protocols of the traffic that will go through this endpoint.
    /// 
    /// - `http`: Endpoint will have `http` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `https` when the `secure` field is set to `true`.
    /// 
    /// - `https`: Endpoint will have `https` traffic, typically on a TCP connection.
    /// 
    /// - `ws`: Endpoint will have `ws` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `wss` when the `secure` field is set to `true`.
    /// 
    /// - `wss`: Endpoint will have `wss` traffic, typically on a TCP connection.
    /// 
    /// - `tcp`: Endpoint will have traffic on a TCP connection, without specifying an application protocol.
    /// 
    /// - `udp`: Endpoint will have traffic on an UDP connection, without specifying an application protocol.
    /// 
    /// Default value is `http`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<CheClusterDevEnvironmentsDefaultComponentsContainerEndpointsProtocol>,
    /// Describes whether the endpoint should be secured and protected by some
    /// authentication process. This requires a protocol of `https` or `wss`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secure: Option<bool>,
    /// Port number to be used within the container component. The same port cannot
    /// be used by two different container components.
    #[serde(rename = "targetPort")]
    pub target_port: i64,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsContainerEndpointsExposure {
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "internal")]
    Internal,
    #[serde(rename = "none")]
    None,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsContainerEndpointsProtocol {
    #[serde(rename = "http")]
    Http,
    #[serde(rename = "https")]
    Https,
    #[serde(rename = "ws")]
    Ws,
    #[serde(rename = "wss")]
    Wss,
    #[serde(rename = "tcp")]
    Tcp,
    #[serde(rename = "udp")]
    Udp,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsContainerEnv {
    pub name: String,
    pub value: String,
}

/// Volume that should be mounted to a component container
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsContainerVolumeMounts {
    /// The volume mount name is the name of an existing `Volume` component.
    /// If several containers mount the same volume name
    /// then they will reuse the same volume and will be able to access to the same files.
    pub name: String,
    /// The path in the component container where the volume should be mounted.
    /// If not path is mentioned, default path is the is `/<name>`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
}

/// Custom component whose logic is implementation-dependant
/// and should be provided by the user
/// possibly through some dedicated controller
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsCustom {
    /// Class of component that the associated implementation controller
    /// should use to process this command with the appropriate logic
    #[serde(rename = "componentClass")]
    pub component_class: String,
    /// Additional free-form configuration for this custom component
    /// that the implementation controller will know how to use
    #[serde(rename = "embeddedResource")]
    pub embedded_resource: BTreeMap<String, serde_json::Value>,
}

/// Allows specifying the definition of an image for outer loop builds
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsImage {
    /// Defines if the image should be built during startup.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "autoBuild")]
    pub auto_build: Option<bool>,
    /// Allows specifying dockerfile type build
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dockerfile: Option<CheClusterDevEnvironmentsDefaultComponentsImageDockerfile>,
    /// Name of the image for the resulting outerloop build
    #[serde(rename = "imageName")]
    pub image_name: String,
    /// Type of image
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imageType")]
    pub image_type: Option<CheClusterDevEnvironmentsDefaultComponentsImageImageType>,
}

/// Allows specifying dockerfile type build
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsImageDockerfile {
    /// The arguments to supply to the dockerfile build.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// Path of source directory to establish build context. Defaults to ${PROJECT_SOURCE} in the container
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "buildContext")]
    pub build_context: Option<String>,
    /// Dockerfile's Devfile Registry source
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "devfileRegistry")]
    pub devfile_registry: Option<CheClusterDevEnvironmentsDefaultComponentsImageDockerfileDevfileRegistry>,
    /// Dockerfile's Git source
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub git: Option<CheClusterDevEnvironmentsDefaultComponentsImageDockerfileGit>,
    /// Specify if a privileged builder pod is required.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "rootRequired")]
    pub root_required: Option<bool>,
    /// Type of Dockerfile src
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "srcType")]
    pub src_type: Option<CheClusterDevEnvironmentsDefaultComponentsImageDockerfileSrcType>,
    /// URI Reference of a Dockerfile.
    /// It can be a full URL or a relative URI from the current devfile as the base URI.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
}

/// Dockerfile's Devfile Registry source
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsImageDockerfileDevfileRegistry {
    /// Id in a devfile registry that contains a Dockerfile. The src in the OCI registry
    /// required for the Dockerfile build will be downloaded for building the image.
    pub id: String,
    /// Devfile Registry URL to pull the Dockerfile from when using the Devfile Registry as Dockerfile src.
    /// To ensure the Dockerfile gets resolved consistently in different environments,
    /// it is recommended to always specify the `devfileRegistryUrl` when `Id` is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "registryUrl")]
    pub registry_url: Option<String>,
}

/// Dockerfile's Git source
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsImageDockerfileGit {
    /// Defines from what the project should be checked out. Required if there are more than one remote configured
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "checkoutFrom")]
    pub checkout_from: Option<CheClusterDevEnvironmentsDefaultComponentsImageDockerfileGitCheckoutFrom>,
    /// Location of the Dockerfile in the Git repository when using git as Dockerfile src.
    /// Defaults to Dockerfile.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileLocation")]
    pub file_location: Option<String>,
    /// The remotes map which should be initialized in the git project.
    /// Projects must have at least one remote configured while StarterProjects & Image Component's Git source can only have at most one remote configured.
    pub remotes: BTreeMap<String, String>,
}

/// Defines from what the project should be checked out. Required if there are more than one remote configured
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsImageDockerfileGitCheckoutFrom {
    /// The remote name should be used as init. Required if there are more than one remote configured
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub remote: Option<String>,
    /// The revision to checkout from. Should be branch name, tag or commit id.
    /// Default branch is used if missing or specified revision is not found.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,
}

/// Allows specifying dockerfile type build
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsImageDockerfileSrcType {
    Uri,
    DevfileRegistry,
    Git,
}

/// Allows specifying the definition of an image for outer loop builds
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsImageImageType {
    Dockerfile,
}

/// Allows importing into the devworkspace the Kubernetes resources
/// defined in a given manifest. For example this allows reusing the Kubernetes
/// definitions used to deploy some runtime components in production.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsKubernetes {
    /// Defines if the component should be deployed during startup.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "deployByDefault")]
    pub deploy_by_default: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoints: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsKubernetesEndpoints>>,
    /// Inlined manifest
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub inlined: Option<String>,
    /// Type of Kubernetes-like location
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "locationType")]
    pub location_type: Option<CheClusterDevEnvironmentsDefaultComponentsKubernetesLocationType>,
    /// Location in a file fetched from a uri.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsKubernetesEndpoints {
    /// Annotations to be added to Kubernetes Ingress or Openshift Route
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotation: Option<BTreeMap<String, String>>,
    /// Map of implementation-dependant string-based free-form attributes.
    /// 
    /// Examples of Che-specific attributes:
    /// 
    /// - cookiesAuthEnabled: "true" / "false",
    /// 
    /// - type: "terminal" / "ide" / "ide-dev",
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Describes how the endpoint should be exposed on the network.
    /// 
    /// - `public` means that the endpoint will be exposed on the public network, typically through
    /// a K8S ingress or an OpenShift route.
    /// 
    /// - `internal` means that the endpoint will be exposed internally outside of the main devworkspace POD,
    /// typically by K8S services, to be consumed by other elements running
    /// on the same cloud internal network.
    /// 
    /// - `none` means that the endpoint will not be exposed and will only be accessible
    /// inside the main devworkspace POD, on a local address.
    /// 
    /// Default value is `public`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exposure: Option<CheClusterDevEnvironmentsDefaultComponentsKubernetesEndpointsExposure>,
    pub name: String,
    /// Path of the endpoint URL
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// Describes the application and transport protocols of the traffic that will go through this endpoint.
    /// 
    /// - `http`: Endpoint will have `http` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `https` when the `secure` field is set to `true`.
    /// 
    /// - `https`: Endpoint will have `https` traffic, typically on a TCP connection.
    /// 
    /// - `ws`: Endpoint will have `ws` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `wss` when the `secure` field is set to `true`.
    /// 
    /// - `wss`: Endpoint will have `wss` traffic, typically on a TCP connection.
    /// 
    /// - `tcp`: Endpoint will have traffic on a TCP connection, without specifying an application protocol.
    /// 
    /// - `udp`: Endpoint will have traffic on an UDP connection, without specifying an application protocol.
    /// 
    /// Default value is `http`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<CheClusterDevEnvironmentsDefaultComponentsKubernetesEndpointsProtocol>,
    /// Describes whether the endpoint should be secured and protected by some
    /// authentication process. This requires a protocol of `https` or `wss`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secure: Option<bool>,
    /// Port number to be used within the container component. The same port cannot
    /// be used by two different container components.
    #[serde(rename = "targetPort")]
    pub target_port: i64,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsKubernetesEndpointsExposure {
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "internal")]
    Internal,
    #[serde(rename = "none")]
    None,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsKubernetesEndpointsProtocol {
    #[serde(rename = "http")]
    Http,
    #[serde(rename = "https")]
    Https,
    #[serde(rename = "ws")]
    Ws,
    #[serde(rename = "wss")]
    Wss,
    #[serde(rename = "tcp")]
    Tcp,
    #[serde(rename = "udp")]
    Udp,
}

/// Allows importing into the devworkspace the Kubernetes resources
/// defined in a given manifest. For example this allows reusing the Kubernetes
/// definitions used to deploy some runtime components in production.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsKubernetesLocationType {
    Uri,
    Inlined,
}

/// Allows importing into the devworkspace the OpenShift resources
/// defined in a given manifest. For example this allows reusing the OpenShift
/// definitions used to deploy some runtime components in production.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsOpenshift {
    /// Defines if the component should be deployed during startup.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "deployByDefault")]
    pub deploy_by_default: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoints: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsOpenshiftEndpoints>>,
    /// Inlined manifest
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub inlined: Option<String>,
    /// Type of Kubernetes-like location
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "locationType")]
    pub location_type: Option<CheClusterDevEnvironmentsDefaultComponentsOpenshiftLocationType>,
    /// Location in a file fetched from a uri.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsOpenshiftEndpoints {
    /// Annotations to be added to Kubernetes Ingress or Openshift Route
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotation: Option<BTreeMap<String, String>>,
    /// Map of implementation-dependant string-based free-form attributes.
    /// 
    /// Examples of Che-specific attributes:
    /// 
    /// - cookiesAuthEnabled: "true" / "false",
    /// 
    /// - type: "terminal" / "ide" / "ide-dev",
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Describes how the endpoint should be exposed on the network.
    /// 
    /// - `public` means that the endpoint will be exposed on the public network, typically through
    /// a K8S ingress or an OpenShift route.
    /// 
    /// - `internal` means that the endpoint will be exposed internally outside of the main devworkspace POD,
    /// typically by K8S services, to be consumed by other elements running
    /// on the same cloud internal network.
    /// 
    /// - `none` means that the endpoint will not be exposed and will only be accessible
    /// inside the main devworkspace POD, on a local address.
    /// 
    /// Default value is `public`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exposure: Option<CheClusterDevEnvironmentsDefaultComponentsOpenshiftEndpointsExposure>,
    pub name: String,
    /// Path of the endpoint URL
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// Describes the application and transport protocols of the traffic that will go through this endpoint.
    /// 
    /// - `http`: Endpoint will have `http` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `https` when the `secure` field is set to `true`.
    /// 
    /// - `https`: Endpoint will have `https` traffic, typically on a TCP connection.
    /// 
    /// - `ws`: Endpoint will have `ws` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `wss` when the `secure` field is set to `true`.
    /// 
    /// - `wss`: Endpoint will have `wss` traffic, typically on a TCP connection.
    /// 
    /// - `tcp`: Endpoint will have traffic on a TCP connection, without specifying an application protocol.
    /// 
    /// - `udp`: Endpoint will have traffic on an UDP connection, without specifying an application protocol.
    /// 
    /// Default value is `http`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<CheClusterDevEnvironmentsDefaultComponentsOpenshiftEndpointsProtocol>,
    /// Describes whether the endpoint should be secured and protected by some
    /// authentication process. This requires a protocol of `https` or `wss`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secure: Option<bool>,
    /// Port number to be used within the container component. The same port cannot
    /// be used by two different container components.
    #[serde(rename = "targetPort")]
    pub target_port: i64,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsOpenshiftEndpointsExposure {
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "internal")]
    Internal,
    #[serde(rename = "none")]
    None,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsOpenshiftEndpointsProtocol {
    #[serde(rename = "http")]
    Http,
    #[serde(rename = "https")]
    Https,
    #[serde(rename = "ws")]
    Ws,
    #[serde(rename = "wss")]
    Wss,
    #[serde(rename = "tcp")]
    Tcp,
    #[serde(rename = "udp")]
    Udp,
}

/// Allows importing into the devworkspace the OpenShift resources
/// defined in a given manifest. For example this allows reusing the OpenShift
/// definitions used to deploy some runtime components in production.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsOpenshiftLocationType {
    Uri,
    Inlined,
}

/// Allows importing a plugin.
/// 
/// Plugins are mainly imported devfiles that contribute components, commands
/// and events as a consistent single unit. They are defined in either YAML files
/// following the devfile syntax,
/// or as `DevWorkspaceTemplate` Kubernetes Custom Resources
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPlugin {
    /// Overrides of commands encapsulated in a parent devfile or a plugin.
    /// Overriding is done according to K8S strategic merge patch standard rules.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commands: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsPluginCommands>>,
    /// Overrides of components encapsulated in a parent devfile or a plugin.
    /// Overriding is done according to K8S strategic merge patch standard rules.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub components: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsPluginComponents>>,
    /// Id in a registry that contains a Devfile yaml file
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// type of location from where the referenced template structure should be retrieved
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "importReferenceType")]
    pub import_reference_type: Option<CheClusterDevEnvironmentsDefaultComponentsPluginImportReferenceType>,
    /// Reference to a Kubernetes CRD of type DevWorkspaceTemplate
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kubernetes: Option<CheClusterDevEnvironmentsDefaultComponentsPluginKubernetes>,
    /// Registry URL to pull the parent devfile from when using id in the parent reference.
    /// To ensure the parent devfile gets resolved consistently in different environments,
    /// it is recommended to always specify the `registryUrl` when `id` is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "registryUrl")]
    pub registry_url: Option<String>,
    /// URI Reference of a parent devfile YAML file.
    /// It can be a full URL or a relative URI with the current devfile as the base URI.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
    /// Specific stack/sample version to pull the parent devfile from, when using id in the parent reference.
    /// To specify `version`, `id` must be defined and used as the import reference source.
    /// `version` can be either a specific stack version, or `latest`.
    /// If no `version` specified, default version will be used.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginCommands {
    /// Command that consists in applying a given component definition,
    /// typically bound to a devworkspace event.
    /// 
    /// For example, when an `apply` command is bound to a `preStart` event,
    /// and references a `container` component, it will start the container as a
    /// K8S initContainer in the devworkspace POD, unless the component has its
    /// `dedicatedPod` field set to `true`.
    /// 
    /// When no `apply` command exist for a given component,
    /// it is assumed the component will be applied at devworkspace start
    /// by default, unless `deployByDefault` for that component is set to false.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub apply: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsApply>,
    /// Map of implementation-dependant free-form YAML attributes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Type of devworkspace command
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "commandType")]
    pub command_type: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsCommandType>,
    /// Composite command that allows executing several sub-commands
    /// either sequentially or concurrently
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub composite: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsComposite>,
    /// CLI Command executed in an existing component container
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsExec>,
    /// Mandatory identifier that allows referencing
    /// this command in composite commands, from
    /// a parent, or in events.
    pub id: String,
}

/// Command that consists in applying a given component definition,
/// typically bound to a devworkspace event.
/// 
/// For example, when an `apply` command is bound to a `preStart` event,
/// and references a `container` component, it will start the container as a
/// K8S initContainer in the devworkspace POD, unless the component has its
/// `dedicatedPod` field set to `true`.
/// 
/// When no `apply` command exist for a given component,
/// it is assumed the component will be applied at devworkspace start
/// by default, unless `deployByDefault` for that component is set to false.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginCommandsApply {
    /// Describes component that will be applied
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub component: Option<String>,
    /// Defines the group this command is part of
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub group: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsApplyGroup>,
    /// Optional label that provides a label for this command
    /// to be used in Editor UI menus for example
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
}

/// Defines the group this command is part of
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginCommandsApplyGroup {
    /// Identifies the default command for a given group kind
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "isDefault")]
    pub is_default: Option<bool>,
    /// Kind of group the command is part of
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsApplyGroupKind>,
}

/// Defines the group this command is part of
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginCommandsApplyGroupKind {
    #[serde(rename = "build")]
    Build,
    #[serde(rename = "run")]
    Run,
    #[serde(rename = "test")]
    Test,
    #[serde(rename = "debug")]
    Debug,
    #[serde(rename = "deploy")]
    Deploy,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginCommandsCommandType {
    Exec,
    Apply,
    Composite,
}

/// Composite command that allows executing several sub-commands
/// either sequentially or concurrently
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginCommandsComposite {
    /// The commands that comprise this composite command
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commands: Option<Vec<String>>,
    /// Defines the group this command is part of
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub group: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsCompositeGroup>,
    /// Optional label that provides a label for this command
    /// to be used in Editor UI menus for example
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    /// Indicates if the sub-commands should be executed concurrently
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parallel: Option<bool>,
}

/// Defines the group this command is part of
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginCommandsCompositeGroup {
    /// Identifies the default command for a given group kind
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "isDefault")]
    pub is_default: Option<bool>,
    /// Kind of group the command is part of
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsCompositeGroupKind>,
}

/// Defines the group this command is part of
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginCommandsCompositeGroupKind {
    #[serde(rename = "build")]
    Build,
    #[serde(rename = "run")]
    Run,
    #[serde(rename = "test")]
    Test,
    #[serde(rename = "debug")]
    Debug,
    #[serde(rename = "deploy")]
    Deploy,
}

/// CLI Command executed in an existing component container
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginCommandsExec {
    /// The actual command-line string
    /// 
    /// Special variables that can be used:
    /// 
    ///  - `$PROJECTS_ROOT`: A path where projects sources are mounted as defined by container component's sourceMapping.
    /// 
    ///  - `$PROJECT_SOURCE`: A path to a project source ($PROJECTS_ROOT/<project-name>). If there are multiple projects, this will point to the directory of the first one.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "commandLine")]
    pub command_line: Option<String>,
    /// Describes component to which given action relates
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub component: Option<String>,
    /// Optional list of environment variables that have to be set
    /// before running the command
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsExecEnv>>,
    /// Defines the group this command is part of
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub group: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsExecGroup>,
    /// Specify whether the command is restarted or not when the source code changes.
    /// If set to `true` the command won't be restarted.
    /// A *hotReloadCapable* `run` or `debug` command is expected to handle file changes on its own and won't be restarted.
    /// A *hotReloadCapable* `build` command is expected to be executed only once and won't be executed again.
    /// This field is taken into account only for commands `build`, `run` and `debug` with `isDefault` set to `true`.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hotReloadCapable")]
    pub hot_reload_capable: Option<bool>,
    /// Optional label that provides a label for this command
    /// to be used in Editor UI menus for example
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    /// Working directory where the command should be executed
    /// 
    /// Special variables that can be used:
    /// 
    ///  - `$PROJECTS_ROOT`: A path where projects sources are mounted as defined by container component's sourceMapping.
    /// 
    ///  - `$PROJECT_SOURCE`: A path to a project source ($PROJECTS_ROOT/<project-name>). If there are multiple projects, this will point to the directory of the first one.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "workingDir")]
    pub working_dir: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginCommandsExecEnv {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// Defines the group this command is part of
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginCommandsExecGroup {
    /// Identifies the default command for a given group kind
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "isDefault")]
    pub is_default: Option<bool>,
    /// Kind of group the command is part of
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<CheClusterDevEnvironmentsDefaultComponentsPluginCommandsExecGroupKind>,
}

/// Defines the group this command is part of
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginCommandsExecGroupKind {
    #[serde(rename = "build")]
    Build,
    #[serde(rename = "run")]
    Run,
    #[serde(rename = "test")]
    Test,
    #[serde(rename = "debug")]
    Debug,
    #[serde(rename = "deploy")]
    Deploy,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponents {
    /// Map of implementation-dependant free-form YAML attributes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Type of component
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "componentType")]
    pub component_type: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsComponentType>,
    /// Allows adding and configuring devworkspace-related containers
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub container: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainer>,
    /// Allows specifying the definition of an image for outer loop builds
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImage>,
    /// Allows importing into the devworkspace the Kubernetes resources
    /// defined in a given manifest. For example this allows reusing the Kubernetes
    /// definitions used to deploy some runtime components in production.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kubernetes: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetes>,
    /// Mandatory name that allows referencing the component
    /// from other elements (such as commands) or from an external
    /// devfile that may reference this component through a parent or a plugin.
    pub name: String,
    /// Allows importing into the devworkspace the OpenShift resources
    /// defined in a given manifest. For example this allows reusing the OpenShift
    /// definitions used to deploy some runtime components in production.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub openshift: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshift>,
    /// Allows specifying the definition of a volume
    /// shared by several other components
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub volume: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsVolume>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsComponentType {
    Container,
    Kubernetes,
    Openshift,
    Volume,
    Image,
}

/// Allows adding and configuring devworkspace-related containers
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainer {
    /// Annotations that should be added to specific resources for this container
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotation: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerAnnotation>,
    /// The arguments to supply to the command running the dockerimage component. The arguments are supplied either to the default command provided in the image or to the overridden command.
    /// 
    /// Defaults to an empty array, meaning use whatever is defined in the image.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// The command to run in the dockerimage component instead of the default one provided in the image.
    /// 
    /// Defaults to an empty array, meaning use whatever is defined in the image.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cpuLimit")]
    pub cpu_limit: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cpuRequest")]
    pub cpu_request: Option<String>,
    /// Specify if a container should run in its own separated pod,
    /// instead of running as part of the main development environment pod.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dedicatedPod")]
    pub dedicated_pod: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoints: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerEndpoints>>,
    /// Environment variables used in this container.
    /// 
    /// The following variables are reserved and cannot be overridden via env:
    /// 
    ///  - `$PROJECTS_ROOT`
    /// 
    ///  - `$PROJECT_SOURCE`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerEnv>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "memoryLimit")]
    pub memory_limit: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "memoryRequest")]
    pub memory_request: Option<String>,
    /// Toggles whether or not the project source code should
    /// be mounted in the component.
    /// 
    /// Defaults to true for all component types except plugins and components that set `dedicatedPod` to true.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "mountSources")]
    pub mount_sources: Option<bool>,
    /// Optional specification of the path in the container where
    /// project sources should be transferred/mounted when `mountSources` is `true`.
    /// When omitted, the default value of /projects is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sourceMapping")]
    pub source_mapping: Option<String>,
    /// List of volumes mounts that should be mounted is this container.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
    pub volume_mounts: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerVolumeMounts>>,
}

/// Annotations that should be added to specific resources for this container
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerAnnotation {
    /// Annotations to be added to deployment
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deployment: Option<BTreeMap<String, String>>,
    /// Annotations to be added to service
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub service: Option<BTreeMap<String, String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerEndpoints {
    /// Annotations to be added to Kubernetes Ingress or Openshift Route
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotation: Option<BTreeMap<String, String>>,
    /// Map of implementation-dependant string-based free-form attributes.
    /// 
    /// Examples of Che-specific attributes:
    /// 
    /// - cookiesAuthEnabled: "true" / "false",
    /// 
    /// - type: "terminal" / "ide" / "ide-dev",
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Describes how the endpoint should be exposed on the network.
    /// 
    /// - `public` means that the endpoint will be exposed on the public network, typically through
    /// a K8S ingress or an OpenShift route.
    /// 
    /// - `internal` means that the endpoint will be exposed internally outside of the main devworkspace POD,
    /// typically by K8S services, to be consumed by other elements running
    /// on the same cloud internal network.
    /// 
    /// - `none` means that the endpoint will not be exposed and will only be accessible
    /// inside the main devworkspace POD, on a local address.
    /// 
    /// Default value is `public`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exposure: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerEndpointsExposure>,
    pub name: String,
    /// Path of the endpoint URL
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// Describes the application and transport protocols of the traffic that will go through this endpoint.
    /// 
    /// - `http`: Endpoint will have `http` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `https` when the `secure` field is set to `true`.
    /// 
    /// - `https`: Endpoint will have `https` traffic, typically on a TCP connection.
    /// 
    /// - `ws`: Endpoint will have `ws` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `wss` when the `secure` field is set to `true`.
    /// 
    /// - `wss`: Endpoint will have `wss` traffic, typically on a TCP connection.
    /// 
    /// - `tcp`: Endpoint will have traffic on a TCP connection, without specifying an application protocol.
    /// 
    /// - `udp`: Endpoint will have traffic on an UDP connection, without specifying an application protocol.
    /// 
    /// Default value is `http`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerEndpointsProtocol>,
    /// Describes whether the endpoint should be secured and protected by some
    /// authentication process. This requires a protocol of `https` or `wss`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secure: Option<bool>,
    /// Port number to be used within the container component. The same port cannot
    /// be used by two different container components.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "targetPort")]
    pub target_port: Option<i64>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerEndpointsExposure {
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "internal")]
    Internal,
    #[serde(rename = "none")]
    None,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerEndpointsProtocol {
    #[serde(rename = "http")]
    Http,
    #[serde(rename = "https")]
    Https,
    #[serde(rename = "ws")]
    Ws,
    #[serde(rename = "wss")]
    Wss,
    #[serde(rename = "tcp")]
    Tcp,
    #[serde(rename = "udp")]
    Udp,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerEnv {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// Volume that should be mounted to a component container
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsContainerVolumeMounts {
    /// The volume mount name is the name of an existing `Volume` component.
    /// If several containers mount the same volume name
    /// then they will reuse the same volume and will be able to access to the same files.
    pub name: String,
    /// The path in the component container where the volume should be mounted.
    /// If not path is mentioned, default path is the is `/<name>`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
}

/// Allows specifying the definition of an image for outer loop builds
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImage {
    /// Defines if the image should be built during startup.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "autoBuild")]
    pub auto_build: Option<bool>,
    /// Allows specifying dockerfile type build
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dockerfile: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfile>,
    /// Name of the image for the resulting outerloop build
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imageName")]
    pub image_name: Option<String>,
    /// Type of image
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imageType")]
    pub image_type: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageImageType>,
}

/// Allows specifying dockerfile type build
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfile {
    /// The arguments to supply to the dockerfile build.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// Path of source directory to establish build context. Defaults to ${PROJECT_SOURCE} in the container
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "buildContext")]
    pub build_context: Option<String>,
    /// Dockerfile's Devfile Registry source
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "devfileRegistry")]
    pub devfile_registry: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfileDevfileRegistry>,
    /// Dockerfile's Git source
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub git: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfileGit>,
    /// Specify if a privileged builder pod is required.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "rootRequired")]
    pub root_required: Option<bool>,
    /// Type of Dockerfile src
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "srcType")]
    pub src_type: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfileSrcType>,
    /// URI Reference of a Dockerfile.
    /// It can be a full URL or a relative URI from the current devfile as the base URI.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
}

/// Dockerfile's Devfile Registry source
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfileDevfileRegistry {
    /// Id in a devfile registry that contains a Dockerfile. The src in the OCI registry
    /// required for the Dockerfile build will be downloaded for building the image.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// Devfile Registry URL to pull the Dockerfile from when using the Devfile Registry as Dockerfile src.
    /// To ensure the Dockerfile gets resolved consistently in different environments,
    /// it is recommended to always specify the `devfileRegistryUrl` when `Id` is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "registryUrl")]
    pub registry_url: Option<String>,
}

/// Dockerfile's Git source
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfileGit {
    /// Defines from what the project should be checked out. Required if there are more than one remote configured
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "checkoutFrom")]
    pub checkout_from: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfileGitCheckoutFrom>,
    /// Location of the Dockerfile in the Git repository when using git as Dockerfile src.
    /// Defaults to Dockerfile.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileLocation")]
    pub file_location: Option<String>,
    /// The remotes map which should be initialized in the git project.
    /// Projects must have at least one remote configured while StarterProjects & Image Component's Git source can only have at most one remote configured.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub remotes: Option<BTreeMap<String, String>>,
}

/// Defines from what the project should be checked out. Required if there are more than one remote configured
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfileGitCheckoutFrom {
    /// The remote name should be used as init. Required if there are more than one remote configured
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub remote: Option<String>,
    /// The revision to checkout from. Should be branch name, tag or commit id.
    /// Default branch is used if missing or specified revision is not found.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,
}

/// Allows specifying dockerfile type build
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageDockerfileSrcType {
    Uri,
    DevfileRegistry,
    Git,
}

/// Allows specifying the definition of an image for outer loop builds
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsImageImageType {
    Dockerfile,
    AutoBuild,
}

/// Allows importing into the devworkspace the Kubernetes resources
/// defined in a given manifest. For example this allows reusing the Kubernetes
/// definitions used to deploy some runtime components in production.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetes {
    /// Defines if the component should be deployed during startup.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "deployByDefault")]
    pub deploy_by_default: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoints: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetesEndpoints>>,
    /// Inlined manifest
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub inlined: Option<String>,
    /// Type of Kubernetes-like location
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "locationType")]
    pub location_type: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetesLocationType>,
    /// Location in a file fetched from a uri.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetesEndpoints {
    /// Annotations to be added to Kubernetes Ingress or Openshift Route
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotation: Option<BTreeMap<String, String>>,
    /// Map of implementation-dependant string-based free-form attributes.
    /// 
    /// Examples of Che-specific attributes:
    /// 
    /// - cookiesAuthEnabled: "true" / "false",
    /// 
    /// - type: "terminal" / "ide" / "ide-dev",
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Describes how the endpoint should be exposed on the network.
    /// 
    /// - `public` means that the endpoint will be exposed on the public network, typically through
    /// a K8S ingress or an OpenShift route.
    /// 
    /// - `internal` means that the endpoint will be exposed internally outside of the main devworkspace POD,
    /// typically by K8S services, to be consumed by other elements running
    /// on the same cloud internal network.
    /// 
    /// - `none` means that the endpoint will not be exposed and will only be accessible
    /// inside the main devworkspace POD, on a local address.
    /// 
    /// Default value is `public`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exposure: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetesEndpointsExposure>,
    pub name: String,
    /// Path of the endpoint URL
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// Describes the application and transport protocols of the traffic that will go through this endpoint.
    /// 
    /// - `http`: Endpoint will have `http` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `https` when the `secure` field is set to `true`.
    /// 
    /// - `https`: Endpoint will have `https` traffic, typically on a TCP connection.
    /// 
    /// - `ws`: Endpoint will have `ws` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `wss` when the `secure` field is set to `true`.
    /// 
    /// - `wss`: Endpoint will have `wss` traffic, typically on a TCP connection.
    /// 
    /// - `tcp`: Endpoint will have traffic on a TCP connection, without specifying an application protocol.
    /// 
    /// - `udp`: Endpoint will have traffic on an UDP connection, without specifying an application protocol.
    /// 
    /// Default value is `http`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetesEndpointsProtocol>,
    /// Describes whether the endpoint should be secured and protected by some
    /// authentication process. This requires a protocol of `https` or `wss`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secure: Option<bool>,
    /// Port number to be used within the container component. The same port cannot
    /// be used by two different container components.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "targetPort")]
    pub target_port: Option<i64>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetesEndpointsExposure {
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "internal")]
    Internal,
    #[serde(rename = "none")]
    None,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetesEndpointsProtocol {
    #[serde(rename = "http")]
    Http,
    #[serde(rename = "https")]
    Https,
    #[serde(rename = "ws")]
    Ws,
    #[serde(rename = "wss")]
    Wss,
    #[serde(rename = "tcp")]
    Tcp,
    #[serde(rename = "udp")]
    Udp,
}

/// Allows importing into the devworkspace the Kubernetes resources
/// defined in a given manifest. For example this allows reusing the Kubernetes
/// definitions used to deploy some runtime components in production.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsKubernetesLocationType {
    Uri,
    Inlined,
}

/// Allows importing into the devworkspace the OpenShift resources
/// defined in a given manifest. For example this allows reusing the OpenShift
/// definitions used to deploy some runtime components in production.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshift {
    /// Defines if the component should be deployed during startup.
    /// 
    /// Default value is `false`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "deployByDefault")]
    pub deploy_by_default: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoints: Option<Vec<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshiftEndpoints>>,
    /// Inlined manifest
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub inlined: Option<String>,
    /// Type of Kubernetes-like location
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "locationType")]
    pub location_type: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshiftLocationType>,
    /// Location in a file fetched from a uri.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshiftEndpoints {
    /// Annotations to be added to Kubernetes Ingress or Openshift Route
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotation: Option<BTreeMap<String, String>>,
    /// Map of implementation-dependant string-based free-form attributes.
    /// 
    /// Examples of Che-specific attributes:
    /// 
    /// - cookiesAuthEnabled: "true" / "false",
    /// 
    /// - type: "terminal" / "ide" / "ide-dev",
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attributes: Option<BTreeMap<String, serde_json::Value>>,
    /// Describes how the endpoint should be exposed on the network.
    /// 
    /// - `public` means that the endpoint will be exposed on the public network, typically through
    /// a K8S ingress or an OpenShift route.
    /// 
    /// - `internal` means that the endpoint will be exposed internally outside of the main devworkspace POD,
    /// typically by K8S services, to be consumed by other elements running
    /// on the same cloud internal network.
    /// 
    /// - `none` means that the endpoint will not be exposed and will only be accessible
    /// inside the main devworkspace POD, on a local address.
    /// 
    /// Default value is `public`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exposure: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshiftEndpointsExposure>,
    pub name: String,
    /// Path of the endpoint URL
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// Describes the application and transport protocols of the traffic that will go through this endpoint.
    /// 
    /// - `http`: Endpoint will have `http` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `https` when the `secure` field is set to `true`.
    /// 
    /// - `https`: Endpoint will have `https` traffic, typically on a TCP connection.
    /// 
    /// - `ws`: Endpoint will have `ws` traffic, typically on a TCP connection.
    /// It will be automaticaly promoted to `wss` when the `secure` field is set to `true`.
    /// 
    /// - `wss`: Endpoint will have `wss` traffic, typically on a TCP connection.
    /// 
    /// - `tcp`: Endpoint will have traffic on a TCP connection, without specifying an application protocol.
    /// 
    /// - `udp`: Endpoint will have traffic on an UDP connection, without specifying an application protocol.
    /// 
    /// Default value is `http`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshiftEndpointsProtocol>,
    /// Describes whether the endpoint should be secured and protected by some
    /// authentication process. This requires a protocol of `https` or `wss`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secure: Option<bool>,
    /// Port number to be used within the container component. The same port cannot
    /// be used by two different container components.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "targetPort")]
    pub target_port: Option<i64>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshiftEndpointsExposure {
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "internal")]
    Internal,
    #[serde(rename = "none")]
    None,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshiftEndpointsProtocol {
    #[serde(rename = "http")]
    Http,
    #[serde(rename = "https")]
    Https,
    #[serde(rename = "ws")]
    Ws,
    #[serde(rename = "wss")]
    Wss,
    #[serde(rename = "tcp")]
    Tcp,
    #[serde(rename = "udp")]
    Udp,
}

/// Allows importing into the devworkspace the OpenShift resources
/// defined in a given manifest. For example this allows reusing the OpenShift
/// definitions used to deploy some runtime components in production.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginComponentsOpenshiftLocationType {
    Uri,
    Inlined,
}

/// Allows specifying the definition of a volume
/// shared by several other components
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginComponentsVolume {
    /// Ephemeral volumes are not stored persistently across restarts. Defaults
    /// to false
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ephemeral: Option<bool>,
    /// Size of the volume
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<String>,
}

/// Allows importing a plugin.
/// 
/// Plugins are mainly imported devfiles that contribute components, commands
/// and events as a consistent single unit. They are defined in either YAML files
/// following the devfile syntax,
/// or as `DevWorkspaceTemplate` Kubernetes Custom Resources
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDefaultComponentsPluginImportReferenceType {
    Uri,
    Id,
    Kubernetes,
}

/// Reference to a Kubernetes CRD of type DevWorkspaceTemplate
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsPluginKubernetes {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
}

/// Allows specifying the definition of a volume
/// shared by several other components
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultComponentsVolume {
    /// Ephemeral volumes are not stored persistently across restarts. Defaults
    /// to false
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ephemeral: Option<bool>,
    /// Size of the volume
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<String>,
}

/// DefaultContainerResources defines the resource requirements (memory/cpu limit/request) used for
/// container components that do not define limits or requests.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultContainerResources {
    /// Claims lists the names of resources, defined in spec.resourceClaims,
    /// that are used by this container.
    /// 
    /// This field depends on the
    /// DynamicResourceAllocation feature gate.
    /// 
    /// This field is immutable. It can only be set for containers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<CheClusterDevEnvironmentsDefaultContainerResourcesClaims>>,
    /// Limits describes the maximum amount of compute resources allowed.
    /// More info: <https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<BTreeMap<String, IntOrString>>,
    /// Requests describes the minimum amount of compute resources required.
    /// If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
    /// otherwise to an implementation-defined value. Requests cannot exceed Limits.
    /// More info: <https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests: Option<BTreeMap<String, IntOrString>>,
}

/// ResourceClaim references one entry in PodSpec.ResourceClaims.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultContainerResourcesClaims {
    /// Name must match the name of one entry in pod.spec.resourceClaims of
    /// the Pod where this field is used. It makes that resource available
    /// inside a container.
    pub name: String,
    /// Request is the name chosen for a request in the referenced claim.
    /// If empty, everything from the claim is made available, otherwise
    /// only the result of this request.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<String>,
}

/// User's default namespace.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultNamespace {
    /// Indicates if is allowed to automatically create a user namespace.
    /// If it set to false, then user namespace must be pre-created by a cluster administrator.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "autoProvision")]
    pub auto_provision: Option<bool>,
    /// If you don't create the user namespaces in advance, this field defines the Kubernetes namespace created when you start your first workspace.
    /// You can use `<username>` and `<userid>` placeholders, such as che-workspace-<username>.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub template: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsDefaultPlugins {
    /// The editor ID to specify default plug-ins for.
    /// The plugin ID must have `publisher/name/version` format.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub editor: Option<String>,
    /// Default plug-in URIs for the specified editor.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plugins: Option<Vec<String>>,
}

/// Development environment default configuration options.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsDeploymentStrategy {
    Recreate,
    RollingUpdate,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsEditorsDownloadUrls {
    /// The editor ID must have `publisher/name/version` format.
    pub editor: String,
    pub url: String,
}

/// GatewayContainer configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainer {
    /// List of environment variables to set in the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterDevEnvironmentsGatewayContainerEnv>>,
    /// Container image. Omit it or leave it empty to use the default container image provided by the Operator.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// Image pull policy. Default value is `Always` for `nightly`, `next` or `latest` images, and `IfNotPresent` in other cases.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<CheClusterDevEnvironmentsGatewayContainerImagePullPolicy>,
    /// Container name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Compute resources required by this container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<CheClusterDevEnvironmentsGatewayContainerResources>,
}

/// EnvVar represents an environment variable present in a Container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerEnv {
    /// Name of the environment variable.
    /// May consist of any printable ASCII characters except '='.
    pub name: String,
    /// Variable references $(VAR_NAME) are expanded
    /// using the previously defined environment variables in the container and
    /// any service environment variables. If a variable cannot be resolved,
    /// the reference in the input string will be unchanged. Double $$ are reduced
    /// to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.
    /// "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
    /// Escaped references will never be expanded, regardless of whether the variable
    /// exists or not.
    /// Defaults to "".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Source for the environment variable's value. Cannot be used if value is not empty.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
    pub value_from: Option<CheClusterDevEnvironmentsGatewayContainerEnvValueFrom>,
}

/// Source for the environment variable's value. Cannot be used if value is not empty.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerEnvValueFrom {
    /// Selects a key of a ConfigMap.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<CheClusterDevEnvironmentsGatewayContainerEnvValueFromConfigMapKeyRef>,
    /// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
    /// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<CheClusterDevEnvironmentsGatewayContainerEnvValueFromFieldRef>,
    /// FileKeyRef selects a key of the env file.
    /// Requires the EnvFiles feature gate to be enabled.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileKeyRef")]
    pub file_key_ref: Option<CheClusterDevEnvironmentsGatewayContainerEnvValueFromFileKeyRef>,
    /// Selects a resource of the container: only resources limits and requests
    /// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<CheClusterDevEnvironmentsGatewayContainerEnvValueFromResourceFieldRef>,
    /// Selects a key of a secret in the pod's namespace
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<CheClusterDevEnvironmentsGatewayContainerEnvValueFromSecretKeyRef>,
}

/// Selects a key of a ConfigMap.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerEnvValueFromConfigMapKeyRef {
    /// The key to select.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the ConfigMap or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
/// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerEnvValueFromFieldRef {
    /// Version of the schema the FieldPath is written in terms of, defaults to "v1".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    /// Path of the field to select in the specified API version.
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

/// FileKeyRef selects a key of the env file.
/// Requires the EnvFiles feature gate to be enabled.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerEnvValueFromFileKeyRef {
    /// The key within the env file. An invalid key will prevent the pod from starting.
    /// The keys defined within a source may consist of any printable ASCII characters except '='.
    /// During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.
    pub key: String,
    /// Specify whether the file or its key must be defined. If the file or key
    /// does not exist, then the env var is not published.
    /// If optional is set to true and the specified key does not exist,
    /// the environment variable will not be set in the Pod's containers.
    /// 
    /// If optional is set to false and the specified key does not exist,
    /// an error will be returned during Pod creation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
    /// The path within the volume from which to select the file.
    /// Must be relative and may not contain the '..' path or start with '..'.
    pub path: String,
    /// The name of the volume mount containing the env file.
    #[serde(rename = "volumeName")]
    pub volume_name: String,
}

/// Selects a resource of the container: only resources limits and requests
/// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerEnvValueFromResourceFieldRef {
    /// Container name: required for volumes, optional for env vars
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the output format of the exposed resources, defaults to "1"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    /// Required: resource to select
    pub resource: String,
}

/// Selects a key of a secret in the pod's namespace
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerEnvValueFromSecretKeyRef {
    /// The key of the secret to select from.  Must be a valid secret key.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the Secret or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// GatewayContainer configuration.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsGatewayContainerImagePullPolicy {
    Always,
    IfNotPresent,
    Never,
}

/// Compute resources required by this container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerResources {
    /// Describes the maximum amount of compute resources allowed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<CheClusterDevEnvironmentsGatewayContainerResourcesLimits>,
    /// Describes the minimum amount of compute resources required.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<CheClusterDevEnvironmentsGatewayContainerResourcesRequest>,
}

/// Describes the maximum amount of compute resources allowed.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerResourcesLimits {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Describes the minimum amount of compute resources required.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsGatewayContainerResourcesRequest {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Development environment default configuration options.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsImagePullPolicy {
    Always,
    IfNotPresent,
    Never,
}

/// Configuration settings related to the workspaces networking.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsNetworking {
    /// External TLS configuration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalTLSConfig")]
    pub external_tls_config: Option<CheClusterDevEnvironmentsNetworkingExternalTlsConfig>,
}

/// External TLS configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsNetworkingExternalTlsConfig {
    /// Annotations to be applied to ingress/route objects when external TLS is enabled.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotations: Option<BTreeMap<String, String>>,
    /// Enabled determines whether external TLS configuration is used.
    /// If set to true, the operator will not set TLS config for ingress/route objects.
    /// Instead, it ensures that any custom TLS configuration will not be reverted on synchronization.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    /// Labels to be applied to ingress/route objects when external TLS is enabled.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub labels: Option<BTreeMap<String, String>>,
}

/// PersistUserHome defines configuration options for persisting the
/// user home directory in workspaces.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsPersistUserHome {
    /// Determines whether the init container that initializes the persistent home directory should be disabled.
    /// When the `/home/user` directory is persisted, the init container is used to initialize the directory before
    /// the workspace starts. If set to true, the init container will not be created.
    /// Disabling the init container allows home persistence to be initialized by the entrypoint present in the workspace's first container component.
    /// This field is not used if the `devEnvironments.persistUserHome.enabled` field is set to false.
    /// The init container is enabled by default.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableInitContainer")]
    pub disable_init_container: Option<bool>,
    /// Determines whether the user home directory in workspaces should persist between
    /// workspace shutdown and startup.
    /// Must be used with the 'per-user' or 'per-workspace' PVC strategy in order to take effect.
    /// Disabled by default.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// Project clone container configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainer {
    /// List of environment variables to set in the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterDevEnvironmentsProjectCloneContainerEnv>>,
    /// Container image. Omit it or leave it empty to use the default container image provided by the Operator.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// Image pull policy. Default value is `Always` for `nightly`, `next` or `latest` images, and `IfNotPresent` in other cases.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<CheClusterDevEnvironmentsProjectCloneContainerImagePullPolicy>,
    /// Container name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Compute resources required by this container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<CheClusterDevEnvironmentsProjectCloneContainerResources>,
}

/// EnvVar represents an environment variable present in a Container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerEnv {
    /// Name of the environment variable.
    /// May consist of any printable ASCII characters except '='.
    pub name: String,
    /// Variable references $(VAR_NAME) are expanded
    /// using the previously defined environment variables in the container and
    /// any service environment variables. If a variable cannot be resolved,
    /// the reference in the input string will be unchanged. Double $$ are reduced
    /// to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.
    /// "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
    /// Escaped references will never be expanded, regardless of whether the variable
    /// exists or not.
    /// Defaults to "".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Source for the environment variable's value. Cannot be used if value is not empty.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
    pub value_from: Option<CheClusterDevEnvironmentsProjectCloneContainerEnvValueFrom>,
}

/// Source for the environment variable's value. Cannot be used if value is not empty.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerEnvValueFrom {
    /// Selects a key of a ConfigMap.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromConfigMapKeyRef>,
    /// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
    /// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromFieldRef>,
    /// FileKeyRef selects a key of the env file.
    /// Requires the EnvFiles feature gate to be enabled.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileKeyRef")]
    pub file_key_ref: Option<CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromFileKeyRef>,
    /// Selects a resource of the container: only resources limits and requests
    /// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromResourceFieldRef>,
    /// Selects a key of a secret in the pod's namespace
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromSecretKeyRef>,
}

/// Selects a key of a ConfigMap.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromConfigMapKeyRef {
    /// The key to select.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the ConfigMap or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
/// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromFieldRef {
    /// Version of the schema the FieldPath is written in terms of, defaults to "v1".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    /// Path of the field to select in the specified API version.
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

/// FileKeyRef selects a key of the env file.
/// Requires the EnvFiles feature gate to be enabled.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromFileKeyRef {
    /// The key within the env file. An invalid key will prevent the pod from starting.
    /// The keys defined within a source may consist of any printable ASCII characters except '='.
    /// During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.
    pub key: String,
    /// Specify whether the file or its key must be defined. If the file or key
    /// does not exist, then the env var is not published.
    /// If optional is set to true and the specified key does not exist,
    /// the environment variable will not be set in the Pod's containers.
    /// 
    /// If optional is set to false and the specified key does not exist,
    /// an error will be returned during Pod creation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
    /// The path within the volume from which to select the file.
    /// Must be relative and may not contain the '..' path or start with '..'.
    pub path: String,
    /// The name of the volume mount containing the env file.
    #[serde(rename = "volumeName")]
    pub volume_name: String,
}

/// Selects a resource of the container: only resources limits and requests
/// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromResourceFieldRef {
    /// Container name: required for volumes, optional for env vars
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the output format of the exposed resources, defaults to "1"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    /// Required: resource to select
    pub resource: String,
}

/// Selects a key of a secret in the pod's namespace
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerEnvValueFromSecretKeyRef {
    /// The key of the secret to select from.  Must be a valid secret key.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the Secret or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Project clone container configuration.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsProjectCloneContainerImagePullPolicy {
    Always,
    IfNotPresent,
    Never,
}

/// Compute resources required by this container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerResources {
    /// Describes the maximum amount of compute resources allowed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<CheClusterDevEnvironmentsProjectCloneContainerResourcesLimits>,
    /// Describes the minimum amount of compute resources required.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<CheClusterDevEnvironmentsProjectCloneContainerResourcesRequest>,
}

/// Describes the maximum amount of compute resources allowed.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerResourcesLimits {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Describes the minimum amount of compute resources required.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsProjectCloneContainerResourcesRequest {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Workspace security configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurity {
    /// Defines the SecurityContext applied to all workspace-related containers.
    /// When set, the specified values are merged with the default SecurityContext configuration.
    /// This setting takes effect only if both `devEnvironments.disableContainerBuildCapabilities`
    /// and `devEnvironments.disableContainerRunCapabilities` are set to `true`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerSecurityContext")]
    pub container_security_context: Option<CheClusterDevEnvironmentsSecurityContainerSecurityContext>,
    /// PodSecurityContext used by all workspace-related pods.
    /// If set, defined values are merged into the default PodSecurityContext configuration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podSecurityContext")]
    pub pod_security_context: Option<CheClusterDevEnvironmentsSecurityPodSecurityContext>,
}

/// Defines the SecurityContext applied to all workspace-related containers.
/// When set, the specified values are merged with the default SecurityContext configuration.
/// This setting takes effect only if both `devEnvironments.disableContainerBuildCapabilities`
/// and `devEnvironments.disableContainerRunCapabilities` are set to `true`.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityContainerSecurityContext {
    /// AllowPrivilegeEscalation controls whether a process can gain more
    /// privileges than its parent process. This bool directly controls if
    /// the no_new_privs flag will be set on the container process.
    /// AllowPrivilegeEscalation is true always when the container is:
    /// 1) run as Privileged
    /// 2) has CAP_SYS_ADMIN
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowPrivilegeEscalation")]
    pub allow_privilege_escalation: Option<bool>,
    /// appArmorProfile is the AppArmor options to use by this container. If set, this profile
    /// overrides the pod's appArmorProfile.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "appArmorProfile")]
    pub app_armor_profile: Option<CheClusterDevEnvironmentsSecurityContainerSecurityContextAppArmorProfile>,
    /// The capabilities to add/drop when running containers.
    /// Defaults to the default set of capabilities granted by the container runtime.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<CheClusterDevEnvironmentsSecurityContainerSecurityContextCapabilities>,
    /// Run container in privileged mode.
    /// Processes in privileged containers are essentially equivalent to root on the host.
    /// Defaults to false.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub privileged: Option<bool>,
    /// procMount denotes the type of proc mount to use for the containers.
    /// The default value is Default which uses the container runtime defaults for
    /// readonly paths and masked paths.
    /// This requires the ProcMountType feature flag to be enabled.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "procMount")]
    pub proc_mount: Option<String>,
    /// Whether this container has a read-only root filesystem.
    /// Default is false.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnlyRootFilesystem")]
    pub read_only_root_filesystem: Option<bool>,
    /// The GID to run the entrypoint of the container process.
    /// Uses runtime default if unset.
    /// May also be set in PodSecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
    pub run_as_group: Option<i64>,
    /// Indicates that the container must run as a non-root user.
    /// If true, the Kubelet will validate the image at runtime to ensure that it
    /// does not run as UID 0 (root) and fail to start the container if it does.
    /// If unset or false, no such validation will be performed.
    /// May also be set in PodSecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
    pub run_as_non_root: Option<bool>,
    /// The UID to run the entrypoint of the container process.
    /// Defaults to user specified in image metadata if unspecified.
    /// May also be set in PodSecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
    /// The SELinux context to be applied to the container.
    /// If unspecified, the container runtime will allocate a random SELinux context for each
    /// container.  May also be set in PodSecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
    pub se_linux_options: Option<CheClusterDevEnvironmentsSecurityContainerSecurityContextSeLinuxOptions>,
    /// The seccomp options to use by this container. If seccomp options are
    /// provided at both the pod & container level, the container options
    /// override the pod options.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
    pub seccomp_profile: Option<CheClusterDevEnvironmentsSecurityContainerSecurityContextSeccompProfile>,
    /// The Windows specific settings applied to all containers.
    /// If unspecified, the options from the PodSecurityContext will be used.
    /// If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is linux.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
    pub windows_options: Option<CheClusterDevEnvironmentsSecurityContainerSecurityContextWindowsOptions>,
}

/// appArmorProfile is the AppArmor options to use by this container. If set, this profile
/// overrides the pod's appArmorProfile.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityContainerSecurityContextAppArmorProfile {
    /// localhostProfile indicates a profile loaded on the node that should be used.
    /// The profile must be preconfigured on the node to work.
    /// Must match the loaded name of the profile.
    /// Must be set if and only if type is "Localhost".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
    pub localhost_profile: Option<String>,
    /// type indicates which kind of AppArmor profile will be applied.
    /// Valid options are:
    ///   Localhost - a profile pre-loaded on the node.
    ///   RuntimeDefault - the container runtime's default profile.
    ///   Unconfined - no AppArmor enforcement.
    #[serde(rename = "type")]
    pub r#type: String,
}

/// The capabilities to add/drop when running containers.
/// Defaults to the default set of capabilities granted by the container runtime.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityContainerSecurityContextCapabilities {
    /// Added capabilities
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub add: Option<Vec<String>>,
    /// Removed capabilities
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub drop: Option<Vec<String>>,
}

/// The SELinux context to be applied to the container.
/// If unspecified, the container runtime will allocate a random SELinux context for each
/// container.  May also be set in PodSecurityContext.  If set in both SecurityContext and
/// PodSecurityContext, the value specified in SecurityContext takes precedence.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityContainerSecurityContextSeLinuxOptions {
    /// Level is SELinux level label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub level: Option<String>,
    /// Role is a SELinux role label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    /// Type is a SELinux type label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<String>,
    /// User is a SELinux user label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

/// The seccomp options to use by this container. If seccomp options are
/// provided at both the pod & container level, the container options
/// override the pod options.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityContainerSecurityContextSeccompProfile {
    /// localhostProfile indicates a profile defined in a file on the node should be used.
    /// The profile must be preconfigured on the node to work.
    /// Must be a descending path, relative to the kubelet's configured seccomp profile location.
    /// Must be set if type is "Localhost". Must NOT be set for any other type.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
    pub localhost_profile: Option<String>,
    /// type indicates which kind of seccomp profile will be applied.
    /// Valid options are:
    /// 
    /// Localhost - a profile defined in a file on the node should be used.
    /// RuntimeDefault - the container runtime default profile should be used.
    /// Unconfined - no profile should be applied.
    #[serde(rename = "type")]
    pub r#type: String,
}

/// The Windows specific settings applied to all containers.
/// If unspecified, the options from the PodSecurityContext will be used.
/// If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.
/// Note that this field cannot be set when spec.os.name is linux.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityContainerSecurityContextWindowsOptions {
    /// GMSACredentialSpec is where the GMSA admission webhook
    /// (<https://github.com/kubernetes-sigs/windows-gmsa)> inlines the contents of the
    /// GMSA credential spec named by the GMSACredentialSpecName field.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
    pub gmsa_credential_spec: Option<String>,
    /// GMSACredentialSpecName is the name of the GMSA credential spec to use.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
    pub gmsa_credential_spec_name: Option<String>,
    /// HostProcess determines if a container should be run as a 'Host Process' container.
    /// All of a Pod's containers must have the same effective HostProcess value
    /// (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers).
    /// In addition, if HostProcess is true then HostNetwork must also be set to true.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
    pub host_process: Option<bool>,
    /// The UserName in Windows to run the entrypoint of the container process.
    /// Defaults to the user specified in image metadata if unspecified.
    /// May also be set in PodSecurityContext. If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
    pub run_as_user_name: Option<String>,
}

/// PodSecurityContext used by all workspace-related pods.
/// If set, defined values are merged into the default PodSecurityContext configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityPodSecurityContext {
    /// appArmorProfile is the AppArmor options to use by the containers in this pod.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "appArmorProfile")]
    pub app_armor_profile: Option<CheClusterDevEnvironmentsSecurityPodSecurityContextAppArmorProfile>,
    /// A special supplemental group that applies to all containers in a pod.
    /// Some volume types allow the Kubelet to change the ownership of that volume
    /// to be owned by the pod:
    /// 
    /// 1. The owning GID will be the FSGroup
    /// 2. The setgid bit is set (new files created in the volume will be owned by FSGroup)
    /// 
    /// If unset, the Kubelet will not modify the ownership and permissions of any volume.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroup")]
    pub fs_group: Option<i64>,
    /// fsGroupChangePolicy defines behavior of changing ownership and permission of the volume
    /// before being exposed inside Pod. This field will only apply to
    /// volume types which support fsGroup based ownership(and permissions).
    /// It will have no effect on ephemeral volume types such as: secret, configmaps
    /// and emptydir.
    /// Valid values are "OnRootMismatch" and "Always". If not specified, "Always" is used.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroupChangePolicy")]
    pub fs_group_change_policy: Option<String>,
    /// The GID to run the entrypoint of the container process.
    /// Uses runtime default if unset.
    /// May also be set in SecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence
    /// for that container.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
    pub run_as_group: Option<i64>,
    /// Indicates that the container must run as a non-root user.
    /// If true, the Kubelet will validate the image at runtime to ensure that it
    /// does not run as UID 0 (root) and fail to start the container if it does.
    /// If unset or false, no such validation will be performed.
    /// May also be set in SecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
    pub run_as_non_root: Option<bool>,
    /// The UID to run the entrypoint of the container process.
    /// Defaults to user specified in image metadata if unspecified.
    /// May also be set in SecurityContext.  If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence
    /// for that container.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
    /// seLinuxChangePolicy defines how the container's SELinux label is applied to all volumes used by the Pod.
    /// It has no effect on nodes that do not support SELinux or to volumes does not support SELinux.
    /// Valid values are "MountOption" and "Recursive".
    /// 
    /// "Recursive" means relabeling of all files on all Pod volumes by the container runtime.
    /// This may be slow for large volumes, but allows mixing privileged and unprivileged Pods sharing the same volume on the same node.
    /// 
    /// "MountOption" mounts all eligible Pod volumes with `-o context` mount option.
    /// This requires all Pods that share the same volume to use the same SELinux label.
    /// It is not possible to share the same volume among privileged and unprivileged Pods.
    /// Eligible volumes are in-tree FibreChannel and iSCSI volumes, and all CSI volumes
    /// whose CSI driver announces SELinux support by setting spec.seLinuxMount: true in their
    /// CSIDriver instance. Other volumes are always re-labelled recursively.
    /// "MountOption" value is allowed only when SELinuxMount feature gate is enabled.
    /// 
    /// If not specified and SELinuxMount feature gate is enabled, "MountOption" is used.
    /// If not specified and SELinuxMount feature gate is disabled, "MountOption" is used for ReadWriteOncePod volumes
    /// and "Recursive" for all other volumes.
    /// 
    /// This field affects only Pods that have SELinux label set, either in PodSecurityContext or in SecurityContext of all containers.
    /// 
    /// All Pods that use the same volume should use the same seLinuxChangePolicy, otherwise some pods can get stuck in ContainerCreating state.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxChangePolicy")]
    pub se_linux_change_policy: Option<String>,
    /// The SELinux context to be applied to all containers.
    /// If unspecified, the container runtime will allocate a random SELinux context for each
    /// container.  May also be set in SecurityContext.  If set in
    /// both SecurityContext and PodSecurityContext, the value specified in SecurityContext
    /// takes precedence for that container.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
    pub se_linux_options: Option<CheClusterDevEnvironmentsSecurityPodSecurityContextSeLinuxOptions>,
    /// The seccomp options to use by the containers in this pod.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
    pub seccomp_profile: Option<CheClusterDevEnvironmentsSecurityPodSecurityContextSeccompProfile>,
    /// A list of groups applied to the first process run in each container, in
    /// addition to the container's primary GID and fsGroup (if specified).  If
    /// the SupplementalGroupsPolicy feature is enabled, the
    /// supplementalGroupsPolicy field determines whether these are in addition
    /// to or instead of any group memberships defined in the container image.
    /// If unspecified, no additional groups are added, though group memberships
    /// defined in the container image may still be used, depending on the
    /// supplementalGroupsPolicy field.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "supplementalGroups")]
    pub supplemental_groups: Option<Vec<i64>>,
    /// Defines how supplemental groups of the first container processes are calculated.
    /// Valid values are "Merge" and "Strict". If not specified, "Merge" is used.
    /// (Alpha) Using the field requires the SupplementalGroupsPolicy feature gate to be enabled
    /// and the container runtime must implement support for this feature.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "supplementalGroupsPolicy")]
    pub supplemental_groups_policy: Option<String>,
    /// Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported
    /// sysctls (by the container runtime) might fail to launch.
    /// Note that this field cannot be set when spec.os.name is windows.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sysctls: Option<Vec<CheClusterDevEnvironmentsSecurityPodSecurityContextSysctls>>,
    /// The Windows specific settings applied to all containers.
    /// If unspecified, the options within a container's SecurityContext will be used.
    /// If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.
    /// Note that this field cannot be set when spec.os.name is linux.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
    pub windows_options: Option<CheClusterDevEnvironmentsSecurityPodSecurityContextWindowsOptions>,
}

/// appArmorProfile is the AppArmor options to use by the containers in this pod.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityPodSecurityContextAppArmorProfile {
    /// localhostProfile indicates a profile loaded on the node that should be used.
    /// The profile must be preconfigured on the node to work.
    /// Must match the loaded name of the profile.
    /// Must be set if and only if type is "Localhost".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
    pub localhost_profile: Option<String>,
    /// type indicates which kind of AppArmor profile will be applied.
    /// Valid options are:
    ///   Localhost - a profile pre-loaded on the node.
    ///   RuntimeDefault - the container runtime's default profile.
    ///   Unconfined - no AppArmor enforcement.
    #[serde(rename = "type")]
    pub r#type: String,
}

/// The SELinux context to be applied to all containers.
/// If unspecified, the container runtime will allocate a random SELinux context for each
/// container.  May also be set in SecurityContext.  If set in
/// both SecurityContext and PodSecurityContext, the value specified in SecurityContext
/// takes precedence for that container.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityPodSecurityContextSeLinuxOptions {
    /// Level is SELinux level label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub level: Option<String>,
    /// Role is a SELinux role label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    /// Type is a SELinux type label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<String>,
    /// User is a SELinux user label that applies to the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

/// The seccomp options to use by the containers in this pod.
/// Note that this field cannot be set when spec.os.name is windows.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityPodSecurityContextSeccompProfile {
    /// localhostProfile indicates a profile defined in a file on the node should be used.
    /// The profile must be preconfigured on the node to work.
    /// Must be a descending path, relative to the kubelet's configured seccomp profile location.
    /// Must be set if type is "Localhost". Must NOT be set for any other type.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
    pub localhost_profile: Option<String>,
    /// type indicates which kind of seccomp profile will be applied.
    /// Valid options are:
    /// 
    /// Localhost - a profile defined in a file on the node should be used.
    /// RuntimeDefault - the container runtime default profile should be used.
    /// Unconfined - no profile should be applied.
    #[serde(rename = "type")]
    pub r#type: String,
}

/// Sysctl defines a kernel parameter to be set
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityPodSecurityContextSysctls {
    /// Name of a property to set
    pub name: String,
    /// Value of a property to set
    pub value: String,
}

/// The Windows specific settings applied to all containers.
/// If unspecified, the options within a container's SecurityContext will be used.
/// If set in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes precedence.
/// Note that this field cannot be set when spec.os.name is linux.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsSecurityPodSecurityContextWindowsOptions {
    /// GMSACredentialSpec is where the GMSA admission webhook
    /// (<https://github.com/kubernetes-sigs/windows-gmsa)> inlines the contents of the
    /// GMSA credential spec named by the GMSACredentialSpecName field.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
    pub gmsa_credential_spec: Option<String>,
    /// GMSACredentialSpecName is the name of the GMSA credential spec to use.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
    pub gmsa_credential_spec_name: Option<String>,
    /// HostProcess determines if a container should be run as a 'Host Process' container.
    /// All of a Pod's containers must have the same effective HostProcess value
    /// (it is not allowed to have a mix of HostProcess containers and non-HostProcess containers).
    /// In addition, if HostProcess is true then HostNetwork must also be set to true.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
    pub host_process: Option<bool>,
    /// The UserName in Windows to run the entrypoint of the container process.
    /// Defaults to the user specified in image metadata if unspecified.
    /// May also be set in PodSecurityContext. If set in both SecurityContext and
    /// PodSecurityContext, the value specified in SecurityContext takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
    pub run_as_user_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsServiceAccountTokens {
    /// Audience is the intended audience of the token. A recipient of a token
    /// must identify itself with an identifier specified in the audience of the
    /// token, and otherwise should reject the token. The audience defaults to the
    /// identifier of the apiserver.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub audience: Option<String>,
    /// ExpirationSeconds is the requested duration of validity of the service
    /// account token. As the token approaches expiration, the kubelet volume
    /// plugin will proactively rotate the service account token. The kubelet will
    /// start trying to rotate the token if the token is older than 80 percent of
    /// its time to live or if the token is older than 24 hours. Defaults to 1 hour
    /// and must be at least 10 minutes.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "expirationSeconds")]
    pub expiration_seconds: Option<i64>,
    /// Path within the workspace container at which the token should be mounted.  Must
    /// not contain ':'.
    #[serde(rename = "mountPath")]
    pub mount_path: String,
    /// Identifiable name of the ServiceAccount token.
    /// If multiple ServiceAccount tokens use the same mount path, a generic name will be used
    /// for the projected volume instead.
    pub name: String,
    /// Path is the path relative to the mount point of the file to project the
    /// token into.
    pub path: String,
}

/// Workspaces persistent storage.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsStorage {
    /// PVC settings when using the `per-user` PVC strategy.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "perUserStrategyPvcConfig")]
    pub per_user_strategy_pvc_config: Option<CheClusterDevEnvironmentsStoragePerUserStrategyPvcConfig>,
    /// PVC settings when using the `per-workspace` PVC strategy.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "perWorkspaceStrategyPvcConfig")]
    pub per_workspace_strategy_pvc_config: Option<CheClusterDevEnvironmentsStoragePerWorkspaceStrategyPvcConfig>,
    /// Persistent volume claim strategy for the Che server.
    /// The supported strategies are: `per-user` (all workspaces PVCs in one volume),
    /// `per-workspace` (each workspace is given its own individual PVC)
    /// and `ephemeral` (non-persistent storage where local changes will be lost when
    /// the workspace is stopped.)
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "pvcStrategy")]
    pub pvc_strategy: Option<CheClusterDevEnvironmentsStoragePvcStrategy>,
}

/// PVC settings when using the `per-user` PVC strategy.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsStoragePerUserStrategyPvcConfig {
    /// Persistent Volume Claim size. To update the claim size, the storage class that provisions it must support resizing.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "claimSize")]
    pub claim_size: Option<String>,
    /// StorageAccessMode are the desired access modes the volume should have.
    /// It is used to specify PersistentVolume access mode type to RWO/RWX when using per-user strategy, allowing
    /// user to re-use volume across multiple workspaces.
    /// 
    /// It defaults to ReadWriteOnce if not specified
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageAccessMode")]
    pub storage_access_mode: Option<Vec<String>>,
    /// Storage class for the Persistent Volume Claim. When omitted or left blank, a default storage class is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageClass")]
    pub storage_class: Option<String>,
}

/// PVC settings when using the `per-workspace` PVC strategy.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsStoragePerWorkspaceStrategyPvcConfig {
    /// Persistent Volume Claim size. To update the claim size, the storage class that provisions it must support resizing.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "claimSize")]
    pub claim_size: Option<String>,
    /// StorageAccessMode are the desired access modes the volume should have.
    /// It is used to specify PersistentVolume access mode type to RWO/RWX when using per-user strategy, allowing
    /// user to re-use volume across multiple workspaces.
    /// 
    /// It defaults to ReadWriteOnce if not specified
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageAccessMode")]
    pub storage_access_mode: Option<Vec<String>>,
    /// Storage class for the Persistent Volume Claim. When omitted or left blank, a default storage class is used.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageClass")]
    pub storage_class: Option<String>,
}

/// Workspaces persistent storage.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterDevEnvironmentsStoragePvcStrategy {
    #[serde(rename = "common")]
    Common,
    #[serde(rename = "per-user")]
    PerUser,
    #[serde(rename = "per-workspace")]
    PerWorkspace,
    #[serde(rename = "ephemeral")]
    Ephemeral,
}

/// The pod this Toleration is attached to tolerates any taint that matches
/// the triple <key,value,effect> using the matching operator <operator>.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsTolerations {
    /// Effect indicates the taint effect to match. Empty means match all taint effects.
    /// When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effect: Option<String>,
    /// Key is the taint key that the toleration applies to. Empty means match all taint keys.
    /// If the key is empty, operator must be Exists; this combination means to match all values and all keys.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    /// Operator represents a key's relationship to the value.
    /// Valid operators are Exists and Equal. Defaults to Equal.
    /// Exists is equivalent to wildcard for value, so that a pod can
    /// tolerate all taints of a particular category.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    /// TolerationSeconds represents the period of time the toleration (which must be
    /// of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
    /// it is not set, which means tolerate the taint forever (do not evict). Zero and
    /// negative values will be treated as 0 (evict immediately) by the system.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tolerationSeconds")]
    pub toleration_seconds: Option<i64>,
    /// Value is the taint value the toleration matches to.
    /// If the operator is Exists, the value should be empty, otherwise just a regular string.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// Trusted certificate settings.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsTrustedCerts {
    /// By default, the Operator creates and mounts the 'ca-certs-merged' ConfigMap
    /// containing the CA certificate bundle in users' workspaces at two locations:
    /// '/public-certs' and '/etc/pki/ca-trust/extracted/pem'.
    /// The '/etc/pki/ca-trust/extracted/pem' directory is where the system stores extracted CA certificates
    /// for trusted certificate authorities on Red Hat (e.g., CentOS, Fedora).
    /// This option disables mounting the CA bundle to the '/etc/pki/ca-trust/extracted/pem' directory
    /// while still mounting it to '/public-certs'.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableWorkspaceCaBundleMount")]
    pub disable_workspace_ca_bundle_mount: Option<bool>,
    /// The ConfigMap contains certificates to propagate to the Che components and to provide a particular configuration for Git.
    /// See the following page: <https://www.eclipse.org/che/docs/stable/administration-guide/deploying-che-with-support-for-git-repositories-with-self-signed-certificates/>
    /// The ConfigMap must have a `app.kubernetes.io/part-of=che.eclipse.org` label.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gitTrustedCertsConfigMapName")]
    pub git_trusted_certs_config_map_name: Option<String>,
}

/// User configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterDevEnvironmentsUser {
    /// Additional ClusterRoles assigned to the user.
    /// The role must have `app.kubernetes.io/part-of=che.eclipse.org` label.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clusterRoles")]
    pub cluster_roles: Option<Vec<String>>,
}

/// A configuration that allows users to work with remote Git repositories.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterGitServices {
    /// Enables users to work with repositories hosted on Azure DevOps Service (dev.azure.com).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub azure: Option<Vec<CheClusterGitServicesAzure>>,
    /// Enables users to work with repositories hosted on Bitbucket (bitbucket.org or self-hosted).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bitbucket: Option<Vec<CheClusterGitServicesBitbucket>>,
    /// Enables users to work with repositories hosted on GitHub (github.com or GitHub Enterprise).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub github: Option<Vec<CheClusterGitServicesGithub>>,
    /// Enables users to work with repositories hosted on GitLab (gitlab.com or self-hosted).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub gitlab: Option<Vec<CheClusterGitServicesGitlab>>,
}

/// AzureDevOpsService enables users to work with repositories hosted on Azure DevOps Service (dev.azure.com).
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterGitServicesAzure {
    /// Kubernetes secret, that contains Base64-encoded Azure DevOps Service Application ID and Client Secret.
    /// See the following page: <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-2-for-microsoft-azure-devops-services>
    #[serde(rename = "secretName")]
    pub secret_name: String,
}

/// BitBucketService enables users to work with repositories hosted on Bitbucket (bitbucket.org or self-hosted).
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterGitServicesBitbucket {
    /// Bitbucket server endpoint URL.
    /// Deprecated in favor of `che.eclipse.org/scm-server-endpoint` annotation.
    /// See the following page: <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-1-for-a-bitbucket-server/.>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    /// Kubernetes secret, that contains Base64-encoded Bitbucket OAuth 1.0 or OAuth 2.0 data.
    /// See the following pages for details: <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-1-for-a-bitbucket-server/>
    /// and <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-2-for-the-bitbucket-cloud/.>
    #[serde(rename = "secretName")]
    pub secret_name: String,
}

/// GitHubService enables users to work with repositories hosted on GitHub (GitHub.com or GitHub Enterprise).
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterGitServicesGithub {
    /// Disables subdomain isolation.
    /// Deprecated in favor of `che.eclipse.org/scm-github-disable-subdomain-isolation` annotation.
    /// See the following page for details: <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-2-for-github/.>
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableSubdomainIsolation")]
    pub disable_subdomain_isolation: Option<bool>,
    /// GitHub server endpoint URL.
    /// Deprecated in favor of `che.eclipse.org/scm-server-endpoint` annotation.
    /// See the following page for details: <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-2-for-github/.>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    /// Kubernetes secret, that contains Base64-encoded GitHub OAuth Client id and GitHub OAuth Client secret.
    /// See the following page for details: <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-2-for-github/.>
    #[serde(rename = "secretName")]
    pub secret_name: String,
}

/// GitLabService enables users to work with repositories hosted on GitLab (gitlab.com or self-hosted).
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterGitServicesGitlab {
    /// GitLab server endpoint URL.
    /// Deprecated in favor of `che.eclipse.org/scm-server-endpoint` annotation.
    /// See the following page: <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-2-for-gitlab/.>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    /// Kubernetes secret, that contains Base64-encoded GitHub Application id and GitLab Application Client secret.
    /// See the following page: <https://www.eclipse.org/che/docs/stable/administration-guide/configuring-oauth-2-for-gitlab/.>
    #[serde(rename = "secretName")]
    pub secret_name: String,
}

/// Networking, Che authentication, and TLS configuration.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworking {
    /// Defines annotations which will be set for an Ingress (a route for OpenShift platform).
    /// The defaults for kubernetes platforms are:
    ///     kubernetes.io/ingress.class:                       "nginx"
    ///     nginx.ingress.kubernetes.io/proxy-read-timeout:    "3600",
    ///     nginx.ingress.kubernetes.io/proxy-connect-timeout: "3600",
    ///     nginx.ingress.kubernetes.io/ssl-redirect:          "true"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotations: Option<BTreeMap<String, String>>,
    /// Authentication settings.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auth: Option<CheClusterNetworkingAuth>,
    /// For an OpenShift cluster, the Operator uses the domain to generate a hostname for the route.
    /// The generated hostname follows this pattern: che-<che-namespace>.<domain>. The <che-namespace> is the namespace where the CheCluster CRD is created.
    /// In conjunction with labels, it creates a route served by a non-default Ingress controller.
    /// For a Kubernetes cluster, it contains a global ingress domain. There are no default values: you must specify them.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub domain: Option<String>,
    /// The public hostname of the installed Che server.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hostname: Option<String>,
    /// IngressClassName is the name of an IngressClass cluster resource.
    /// If a class name is defined in both the `IngressClassName` field and the `kubernetes.io/ingress.class` annotation,
    /// `IngressClassName` field takes precedence.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ingressClassName")]
    pub ingress_class_name: Option<String>,
    /// Defines labels which will be set for an Ingress (a route for OpenShift platform).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub labels: Option<BTreeMap<String, String>>,
    /// The name of the secret used to set up Ingress TLS termination.
    /// If the field is an empty string, the default cluster certificate is used.
    /// The secret must have a `app.kubernetes.io/part-of=che.eclipse.org` label.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsSecretName")]
    pub tls_secret_name: Option<String>,
}

/// Authentication settings.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuth {
    /// Advance authorization settings. Determines which users and groups are allowed to access Che.
    /// User is allowed to access Che if he/she is either in the `allowUsers` list or is member of group from `allowGroups` list
    /// and not in neither the `denyUsers` list nor is member of group from `denyGroups` list.
    /// If `allowUsers` and `allowGroups` are empty, then all users are allowed to access Che.
    /// if `denyUsers` and `denyGroups` are empty, then no users are denied to access Che.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "advancedAuthorization")]
    pub advanced_authorization: Option<CheClusterNetworkingAuthAdvancedAuthorization>,
    /// Gateway settings.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub gateway: Option<CheClusterNetworkingAuthGateway>,
    /// Public URL of the Identity Provider server.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "identityProviderURL")]
    pub identity_provider_url: Option<String>,
    /// Identity token to be passed to upstream. There are two types of tokens supported: `id_token` and `access_token`.
    /// Default value is `id_token`.
    /// This field is specific to Che installations made for Kubernetes only and ignored for OpenShift.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "identityToken")]
    pub identity_token: Option<CheClusterNetworkingAuthIdentityToken>,
    /// Inactivity timeout for tokens to set in the OpenShift `OAuthClient` resource used to set up identity federation on the OpenShift side.
    /// 0 means tokens for this client never time out.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "oAuthAccessTokenInactivityTimeoutSeconds")]
    pub o_auth_access_token_inactivity_timeout_seconds: Option<i32>,
    /// Access token max age for tokens to set in the OpenShift `OAuthClient` resource used to set up identity federation on the OpenShift side.
    /// 0 means no expiration.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "oAuthAccessTokenMaxAgeSeconds")]
    pub o_auth_access_token_max_age_seconds: Option<i32>,
    /// Name of the OpenShift `OAuthClient` resource used to set up identity federation on the OpenShift side.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "oAuthClientName")]
    pub o_auth_client_name: Option<String>,
    /// Access Token Scope.
    /// This field is specific to Che installations made for Kubernetes only and ignored for OpenShift.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "oAuthScope")]
    pub o_auth_scope: Option<String>,
    /// Name of the secret set in the OpenShift `OAuthClient` resource used to set up identity federation on the OpenShift side.
    /// For Kubernetes, this can either be the plain text oAuthSecret value, or the name of a kubernetes secret which contains a
    /// key `oAuthSecret` and the value is the secret. NOTE: this secret must exist in the same namespace as the `CheCluster`
    /// resource and contain the label `app.kubernetes.io/part-of=che.eclipse.org`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "oAuthSecret")]
    pub o_auth_secret: Option<String>,
}

/// Advance authorization settings. Determines which users and groups are allowed to access Che.
/// User is allowed to access Che if he/she is either in the `allowUsers` list or is member of group from `allowGroups` list
/// and not in neither the `denyUsers` list nor is member of group from `denyGroups` list.
/// If `allowUsers` and `allowGroups` are empty, then all users are allowed to access Che.
/// if `denyUsers` and `denyGroups` are empty, then no users are denied to access Che.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthAdvancedAuthorization {
    /// List of groups allowed to access Che (currently supported in OpenShift only).
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowGroups")]
    pub allow_groups: Option<Vec<String>>,
    /// List of users allowed to access Che.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowUsers")]
    pub allow_users: Option<Vec<String>>,
    /// List of groups denied to access Che (currently supported in OpenShift only).
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "denyGroups")]
    pub deny_groups: Option<Vec<String>>,
    /// List of users denied to access Che.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "denyUsers")]
    pub deny_users: Option<Vec<String>>,
}

/// Gateway settings.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGateway {
    /// Gateway configuration labels.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configLabels")]
    pub config_labels: Option<BTreeMap<String, String>>,
    /// Deployment override options.
    /// Since gateway deployment consists of several containers, they must be distinguished in the configuration by their names:
    /// - `gateway`
    /// - `configbump`
    /// - `oauth-proxy`
    /// - `kube-rbac-proxy`
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deployment: Option<CheClusterNetworkingAuthGatewayDeployment>,
    /// Configuration for kube-rbac-proxy within the Che gateway pod.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "kubeRbacProxy")]
    pub kube_rbac_proxy: Option<CheClusterNetworkingAuthGatewayKubeRbacProxy>,
    /// Configuration for oauth-proxy within the Che gateway pod.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "oAuthProxy")]
    pub o_auth_proxy: Option<CheClusterNetworkingAuthGatewayOAuthProxy>,
    /// Configuration for Traefik within the Che gateway pod.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub traefik: Option<CheClusterNetworkingAuthGatewayTraefik>,
}

/// Deployment override options.
/// Since gateway deployment consists of several containers, they must be distinguished in the configuration by their names:
/// - `gateway`
/// - `configbump`
/// - `oauth-proxy`
/// - `kube-rbac-proxy`
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeployment {
    /// List of containers belonging to the pod.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<CheClusterNetworkingAuthGatewayDeploymentContainers>>,
    /// The node selector limits the nodes that can run the pod.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
    pub node_selector: Option<BTreeMap<String, String>>,
    /// Security options the pod should run with.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<CheClusterNetworkingAuthGatewayDeploymentSecurityContext>,
    /// The pod tolerations of the component pod limit where the pod can run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tolerations: Option<Vec<CheClusterNetworkingAuthGatewayDeploymentTolerations>>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainers {
    /// List of environment variables to set in the container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<CheClusterNetworkingAuthGatewayDeploymentContainersEnv>>,
    /// Container image. Omit it or leave it empty to use the default container image provided by the Operator.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// Image pull policy. Default value is `Always` for `nightly`, `next` or `latest` images, and `IfNotPresent` in other cases.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<CheClusterNetworkingAuthGatewayDeploymentContainersImagePullPolicy>,
    /// Container name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Compute resources required by this container.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<CheClusterNetworkingAuthGatewayDeploymentContainersResources>,
}

/// EnvVar represents an environment variable present in a Container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersEnv {
    /// Name of the environment variable.
    /// May consist of any printable ASCII characters except '='.
    pub name: String,
    /// Variable references $(VAR_NAME) are expanded
    /// using the previously defined environment variables in the container and
    /// any service environment variables. If a variable cannot be resolved,
    /// the reference in the input string will be unchanged. Double $$ are reduced
    /// to a single $, which allows for escaping the $(VAR_NAME) syntax: i.e.
    /// "$$(VAR_NAME)" will produce the string literal "$(VAR_NAME)".
    /// Escaped references will never be expanded, regardless of whether the variable
    /// exists or not.
    /// Defaults to "".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Source for the environment variable's value. Cannot be used if value is not empty.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
    pub value_from: Option<CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFrom>,
}

/// Source for the environment variable's value. Cannot be used if value is not empty.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFrom {
    /// Selects a key of a ConfigMap.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromConfigMapKeyRef>,
    /// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
    /// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromFieldRef>,
    /// FileKeyRef selects a key of the env file.
    /// Requires the EnvFiles feature gate to be enabled.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fileKeyRef")]
    pub file_key_ref: Option<CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromFileKeyRef>,
    /// Selects a resource of the container: only resources limits and requests
    /// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromResourceFieldRef>,
    /// Selects a key of a secret in the pod's namespace
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromSecretKeyRef>,
}

/// Selects a key of a ConfigMap.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromConfigMapKeyRef {
    /// The key to select.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the ConfigMap or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Selects a field of the pod: supports metadata.name, metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
/// spec.nodeName, spec.serviceAccountName, status.hostIP, status.podIP, status.podIPs.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromFieldRef {
    /// Version of the schema the FieldPath is written in terms of, defaults to "v1".
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    /// Path of the field to select in the specified API version.
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

/// FileKeyRef selects a key of the env file.
/// Requires the EnvFiles feature gate to be enabled.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromFileKeyRef {
    /// The key within the env file. An invalid key will prevent the pod from starting.
    /// The keys defined within a source may consist of any printable ASCII characters except '='.
    /// During Alpha stage of the EnvFiles feature gate, the key size is limited to 128 characters.
    pub key: String,
    /// Specify whether the file or its key must be defined. If the file or key
    /// does not exist, then the env var is not published.
    /// If optional is set to true and the specified key does not exist,
    /// the environment variable will not be set in the Pod's containers.
    /// 
    /// If optional is set to false and the specified key does not exist,
    /// an error will be returned during Pod creation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
    /// The path within the volume from which to select the file.
    /// Must be relative and may not contain the '..' path or start with '..'.
    pub path: String,
    /// The name of the volume mount containing the env file.
    #[serde(rename = "volumeName")]
    pub volume_name: String,
}

/// Selects a resource of the container: only resources limits and requests
/// (limits.cpu, limits.memory, limits.ephemeral-storage, requests.cpu, requests.memory and requests.ephemeral-storage) are currently supported.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromResourceFieldRef {
    /// Container name: required for volumes, optional for env vars
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    /// Specifies the output format of the exposed resources, defaults to "1"
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    /// Required: resource to select
    pub resource: String,
}

/// Selects a key of a secret in the pod's namespace
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersEnvValueFromSecretKeyRef {
    /// The key of the secret to select from.  Must be a valid secret key.
    pub key: String,
    /// Name of the referent.
    /// This field is effectively required, but due to backwards compatibility is
    /// allowed to be empty. Instances of this type with an empty value here are
    /// almost certainly wrong.
    /// More info: <https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names>
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Specify whether the Secret or its key must be defined
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

/// Container custom settings.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterNetworkingAuthGatewayDeploymentContainersImagePullPolicy {
    Always,
    IfNotPresent,
    Never,
}

/// Compute resources required by this container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersResources {
    /// Describes the maximum amount of compute resources allowed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<CheClusterNetworkingAuthGatewayDeploymentContainersResourcesLimits>,
    /// Describes the minimum amount of compute resources required.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub request: Option<CheClusterNetworkingAuthGatewayDeploymentContainersResourcesRequest>,
}

/// Describes the maximum amount of compute resources allowed.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersResourcesLimits {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Describes the minimum amount of compute resources required.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentContainersResourcesRequest {
    /// CPU, in cores. (500m = .5 cores)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cpu: Option<IntOrString>,
    /// Memory, in bytes. (500Gi = 500GiB = 500 * 1024 * 1024 * 1024)
    /// If the value is not specified, then the default value is set depending on the component.
    /// If value is `0`, then no value is set for the component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<IntOrString>,
}

/// Security options the pod should run with.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentSecurityContext {
    /// A special supplemental group that applies to all containers in a pod. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroup")]
    pub fs_group: Option<i64>,
    /// The UID to run the entrypoint of the container process. The default value is `1724`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
}

/// The pod this Toleration is attached to tolerates any taint that matches
/// the triple <key,value,effect> using the matching operator <operator>.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayDeploymentTolerations {
    /// Effect indicates the taint effect to match. Empty means match all taint effects.
    /// When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effect: Option<String>,
    /// Key is the taint key that the toleration applies to. Empty means match all taint keys.
    /// If the key is empty, operator must be Exists; this combination means to match all values and all keys.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    /// Operator represents a key's relationship to the value.
    /// Valid operators are Exists and Equal. Defaults to Equal.
    /// Exists is equivalent to wildcard for value, so that a pod can
    /// tolerate all taints of a particular category.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    /// TolerationSeconds represents the period of time the toleration (which must be
    /// of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
    /// it is not set, which means tolerate the taint forever (do not evict). Zero and
    /// negative values will be treated as 0 (evict immediately) by the system.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tolerationSeconds")]
    pub toleration_seconds: Option<i64>,
    /// Value is the taint value the toleration matches to.
    /// If the operator is Exists, the value should be empty, otherwise just a regular string.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// Configuration for kube-rbac-proxy within the Che gateway pod.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayKubeRbacProxy {
    /// The glog log level for the kube-rbac-proxy container within the gateway pod. Larger values represent a higher verbosity. The default value is `0`.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logLevel")]
    pub log_level: Option<i32>,
}

/// Configuration for oauth-proxy within the Che gateway pod.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayOAuthProxy {
    /// Expire timeframe for cookie. If set to 0, cookie becomes a session-cookie which will expire when the browser is closed.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cookieExpireSeconds")]
    pub cookie_expire_seconds: Option<i32>,
}

/// Configuration for Traefik within the Che gateway pod.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterNetworkingAuthGatewayTraefik {
    /// The log level for the Traefik container within the gateway pod: `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL`, or `PANIC`. The default value is `INFO`
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logLevel")]
    pub log_level: Option<CheClusterNetworkingAuthGatewayTraefikLogLevel>,
}

/// Configuration for Traefik within the Che gateway pod.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterNetworkingAuthGatewayTraefikLogLevel {
    #[serde(rename = "DEBUG")]
    Debug,
    #[serde(rename = "INFO")]
    Info,
    #[serde(rename = "WARN")]
    Warn,
    #[serde(rename = "ERROR")]
    Error,
    #[serde(rename = "FATAL")]
    Fatal,
    #[serde(rename = "PANIC")]
    Panic,
}

/// Authentication settings.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum CheClusterNetworkingAuthIdentityToken {
    #[serde(rename = "id_token")]
    IdToken,
    #[serde(rename = "access_token")]
    AccessToken,
}

/// Defines the observed state of Che installation.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct CheClusterStatus {
    /// Specifies the current phase of the Che deployment.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "chePhase")]
    pub che_phase: Option<String>,
    /// Public URL of the Che server.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cheURL")]
    pub che_url: Option<String>,
    /// Currently installed Che version.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cheVersion")]
    pub che_version: Option<String>,
    /// Deprecated the public URL of the internal devfile registry.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "devfileRegistryURL")]
    pub devfile_registry_url: Option<String>,
    /// Specifies the current phase of the gateway deployment.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gatewayPhase")]
    pub gateway_phase: Option<String>,
    /// A human readable message indicating details about why the Che deployment is in the current phase.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// The public URL of the internal plug-in registry.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "pluginRegistryURL")]
    pub plugin_registry_url: Option<String>,
    /// A brief CamelCase message indicating details about why the Che deployment is in the current phase.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    /// The resolved workspace base domain. This is either the copy of the explicitly defined property of the
    /// same name in the spec or, if it is undefined in the spec and we're running on OpenShift, the automatically
    /// resolved basedomain for routes.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "workspaceBaseDomain")]
    pub workspace_base_domain: Option<String>,
}