kcr_app_redislabs_com 3.20260530.90154

// WARNING: generated by kopium - manual changes will be overwritten
// kopium command: kopium --docs --derive=Default --derive=PartialEq --smart-derive-elision --filename crd-catalog/RedisLabs/redis-enterprise-k8s-docs/app.redislabs.com/v1alpha1/redisenterpriseclusters.yaml
// kopium version: 0.23.0

#[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::*;

#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[kube(group = "app.redislabs.com", version = "v1alpha1", kind = "RedisEnterpriseCluster", plural = "redisenterpriseclusters")]
#[kube(namespaced)]
#[kube(status = "RedisEnterpriseClusterStatus")]
#[kube(schema = "disabled")]
#[kube(derive="Default")]
#[kube(derive="PartialEq")]
pub struct RedisEnterpriseClusterSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "activeActive")]
    pub active_active: Option<RedisEnterpriseClusterActiveActive>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "antiAffinityAdditionalTopologyKeys")]
    pub anti_affinity_additional_topology_keys: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auditing: Option<RedisEnterpriseClusterAuditing>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub backup: Option<RedisEnterpriseClusterBackup>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bootstrapperImageSpec")]
    pub bootstrapper_image_spec: Option<RedisEnterpriseClusterBootstrapperImageSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bootstrapperResources")]
    pub bootstrapper_resources: Option<RedisEnterpriseClusterBootstrapperResources>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub certificates: Option<RedisEnterpriseClusterCertificates>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clusterCredentialSecretName")]
    pub cluster_credential_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clusterCredentialSecretRole")]
    pub cluster_credential_secret_role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clusterCredentialSecretType")]
    pub cluster_credential_secret_type: Option<RedisEnterpriseClusterClusterCredentialSecretType>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clusterRecovery")]
    pub cluster_recovery: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerTimezone")]
    pub container_timezone: Option<RedisEnterpriseClusterContainerTimezone>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "createServiceAccount")]
    pub create_service_account: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataInternodeEncryption")]
    pub data_internode_encryption: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "encryptPkeys")]
    pub encrypt_pkeys: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforceIPv4")]
    pub enforce_i_pv4: Option<bool>,
    /// ADVANCED USAGE: use carefully. Add environment variables to RS StatefulSet's containers.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "extraEnvVars")]
    pub extra_env_vars: Option<Vec<RedisEnterpriseClusterExtraEnvVars>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "extraLabels")]
    pub extra_labels: Option<BTreeMap<String, String>>,
    /// Adds hostAliases entries to the Redis Enterprise pods
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostAliases")]
    pub host_aliases: Option<Vec<RedisEnterpriseClusterHostAliases>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ingressOrRouteSpec")]
    pub ingress_or_route_spec: Option<RedisEnterpriseClusterIngressOrRouteSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ldap: Option<RedisEnterpriseClusterLdap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub license: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "licenseSecretName")]
    pub license_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
    pub node_selector: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nodes: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ocspConfiguration")]
    pub ocsp_configuration: Option<RedisEnterpriseClusterOcspConfiguration>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ossClusterSettings")]
    pub oss_cluster_settings: Option<RedisEnterpriseClusterOssClusterSettings>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "persistentSpec")]
    pub persistent_spec: Option<RedisEnterpriseClusterPersistentSpec>,
    /// annotations for the service rigger and redis enterprise pods
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podAnnotations")]
    pub pod_annotations: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podAntiAffinity")]
    pub pod_anti_affinity: Option<RedisEnterpriseClusterPodAntiAffinity>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podStartingPolicy")]
    pub pod_starting_policy: Option<RedisEnterpriseClusterPodStartingPolicy>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podTolerations")]
    pub pod_tolerations: Option<Vec<RedisEnterpriseClusterPodTolerations>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "priorityClassName")]
    pub priority_class_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "pullSecrets")]
    pub pull_secrets: Option<Vec<RedisEnterpriseClusterPullSecrets>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "rackAwarenessNodeLabel")]
    pub rack_awareness_node_label: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseAdditionalPodSpecAttributes")]
    pub redis_enterprise_additional_pod_spec_attributes: Option<BTreeMap<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseIPFamily")]
    pub redis_enterprise_ip_family: Option<RedisEnterpriseClusterRedisEnterpriseIpFamily>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseImageSpec")]
    pub redis_enterprise_image_spec: Option<RedisEnterpriseClusterRedisEnterpriseImageSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseNodeResources")]
    pub redis_enterprise_node_resources: Option<RedisEnterpriseClusterRedisEnterpriseNodeResources>,
    /// annotations for redis enterprise pod
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterprisePodAnnotations")]
    pub redis_enterprise_pod_annotations: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseServicesConfiguration")]
    pub redis_enterprise_services_configuration: Option<RedisEnterpriseClusterRedisEnterpriseServicesConfiguration>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseServicesRiggerImageSpec")]
    pub redis_enterprise_services_rigger_image_spec: Option<RedisEnterpriseClusterRedisEnterpriseServicesRiggerImageSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseServicesRiggerResources")]
    pub redis_enterprise_services_rigger_resources: Option<RedisEnterpriseClusterRedisEnterpriseServicesRiggerResources>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseTerminationGracePeriodSeconds")]
    pub redis_enterprise_termination_grace_period_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseVolumeMounts")]
    pub redis_enterprise_volume_mounts: Option<Vec<RedisEnterpriseClusterRedisEnterpriseVolumeMounts>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisOnFlashSpec")]
    pub redis_on_flash_spec: Option<RedisEnterpriseClusterRedisOnFlashSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisUpgradePolicy")]
    pub redis_upgrade_policy: Option<RedisEnterpriseClusterRedisUpgradePolicy>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resp3Default")]
    pub resp3_default: Option<bool>,
    /// The security configuration that will be applied to RS pods.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<RedisEnterpriseClusterSecurityContext>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAccountName")]
    pub service_account_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub services: Option<RedisEnterpriseClusterServices>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "servicesRiggerSpec")]
    pub services_rigger_spec: Option<RedisEnterpriseClusterServicesRiggerSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sideContainersSpec")]
    pub side_containers_spec: Option<Vec<BTreeMap<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "slaveHA")]
    pub slave_ha: Option<RedisEnterpriseClusterSlaveHa>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sso: Option<RedisEnterpriseClusterSso>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "uiAnnotations")]
    pub ui_annotations: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "uiServiceType")]
    pub ui_service_type: Option<RedisEnterpriseClusterUiServiceType>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "upgradeSpec")]
    pub upgrade_spec: Option<RedisEnterpriseClusterUpgradeSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "usageMeter")]
    pub usage_meter: Option<RedisEnterpriseClusterUsageMeter>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "userDefinedModules")]
    pub user_defined_modules: Option<Vec<RedisEnterpriseClusterUserDefinedModules>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "vaultCASecret")]
    pub vault_ca_secret: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub volumes: Option<Vec<RedisEnterpriseClusterVolumes>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterActiveActive {
    #[serde(rename = "apiIngressUrl")]
    pub api_ingress_url: String,
    #[serde(rename = "dbIngressSuffix")]
    pub db_ingress_suffix: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ingressAnnotations")]
    pub ingress_annotations: Option<BTreeMap<String, String>>,
    pub method: RedisEnterpriseClusterActiveActiveMethod,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterActiveActiveMethod {
    #[serde(rename = "openShiftRoute")]
    OpenShiftRoute,
    #[serde(rename = "ingress")]
    Ingress,
    #[serde(rename = "istio")]
    Istio,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterAuditing {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<RedisEnterpriseClusterAuditingConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dbConnsAuditing")]
    pub db_conns_auditing: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterAuditingConfig {
    #[serde(rename = "auditAddress")]
    pub audit_address: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "auditPort")]
    pub audit_port: Option<i64>,
    #[serde(rename = "auditProtocol")]
    pub audit_protocol: RedisEnterpriseClusterAuditingConfigAuditProtocol,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "auditReconnectInterval")]
    pub audit_reconnect_interval: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "auditReconnectMaxAttempts")]
    pub audit_reconnect_max_attempts: Option<i64>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterAuditingConfigAuditProtocol {
    #[serde(rename = "TCP")]
    Tcp,
    #[serde(rename = "local")]
    Local,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterBackup {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub s3: Option<RedisEnterpriseClusterBackupS3>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterBackupS3 {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "caCertificateSecretName")]
    pub ca_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterBootstrapperImageSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "digestHash")]
    pub digest_hash: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repository: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "versionTag")]
    pub version_tag: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterBootstrapperResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<RedisEnterpriseClusterBootstrapperResourcesClaims>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<BTreeMap<String, IntOrString>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests: Option<BTreeMap<String, IntOrString>>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterCertificates {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiCertificateSecretName")]
    pub api_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cmCertificateSecretName")]
    pub cm_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cpInternodeEncryptionCertificateSecretName")]
    pub cp_internode_encryption_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dpInternodeEncryptionCertificateSecretName")]
    pub dp_internode_encryption_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ldapClientCertificateSecretName")]
    pub ldap_client_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "metricsExporterCertificateSecretName")]
    pub metrics_exporter_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "proxyCertificateSecretName")]
    pub proxy_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ssoIssuerCertificateSecretName")]
    pub sso_issuer_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ssoServiceCertificateSecretName")]
    pub sso_service_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "syncerCertificateSecretName")]
    pub syncer_certificate_secret_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterClusterCredentialSecretType {
    #[serde(rename = "vault")]
    Vault,
    #[serde(rename = "kubernetes")]
    Kubernetes,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterContainerTimezone {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "propagateHost")]
    pub propagate_host: Option<RedisEnterpriseClusterContainerTimezonePropagateHost>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "timezoneName")]
    pub timezone_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterContainerTimezonePropagateHost {
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterExtraEnvVarsValueFrom {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<RedisEnterpriseClusterExtraEnvVarsValueFromConfigMapKeyRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<RedisEnterpriseClusterExtraEnvVarsValueFromFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<RedisEnterpriseClusterExtraEnvVarsValueFromResourceFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<RedisEnterpriseClusterExtraEnvVarsValueFromSecretKeyRef>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterExtraEnvVarsValueFromFieldRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterExtraEnvVarsValueFromResourceFieldRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    pub resource: String,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterIngressOrRouteSpec {
    #[serde(rename = "apiFqdnUrl")]
    pub api_fqdn_url: String,
    #[serde(rename = "dbFqdnSuffix")]
    pub db_fqdn_suffix: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ingressAnnotations")]
    pub ingress_annotations: Option<BTreeMap<String, String>>,
    pub method: RedisEnterpriseClusterIngressOrRouteSpecMethod,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterIngressOrRouteSpecMethod {
    #[serde(rename = "openShiftRoute")]
    OpenShiftRoute,
    #[serde(rename = "ingress")]
    Ingress,
    #[serde(rename = "istio")]
    Istio,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterLdap {
    #[serde(rename = "authenticationQuery")]
    pub authentication_query: RedisEnterpriseClusterLdapAuthenticationQuery,
    #[serde(rename = "authorizationQuery")]
    pub authorization_query: RedisEnterpriseClusterLdapAuthorizationQuery,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bindCredentialsSecretName")]
    pub bind_credentials_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "caCertificateSecretName")]
    pub ca_certificate_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cacheTTLSeconds")]
    pub cache_ttl_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cba: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cbaIdentityOid")]
    pub cba_identity_oid: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cbaIdentitySource")]
    pub cba_identity_source: Option<RedisEnterpriseClusterLdapCbaIdentitySource>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "directoryTimeoutSeconds")]
    pub directory_timeout_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enabledForControlPlane")]
    pub enabled_for_control_plane: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enabledForDataPlane")]
    pub enabled_for_data_plane: Option<bool>,
    pub protocol: RedisEnterpriseClusterLdapProtocol,
    pub servers: Vec<RedisEnterpriseClusterLdapServers>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterLdapAuthenticationQueryQuery {
    pub base: String,
    pub filter: String,
    pub scope: RedisEnterpriseClusterLdapAuthenticationQueryQueryScope,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterLdapAuthenticationQueryQueryScope {
    BaseObject,
    SingleLevel,
    WholeSubtree,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterLdapAuthorizationQueryQuery {
    pub base: String,
    pub filter: String,
    pub scope: RedisEnterpriseClusterLdapAuthorizationQueryQueryScope,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterLdapAuthorizationQueryQueryScope {
    BaseObject,
    SingleLevel,
    WholeSubtree,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterLdapCbaIdentitySource {
    #[serde(rename = "SubjectCN")]
    SubjectCn,
    #[serde(rename = "SubjectOID")]
    SubjectOid,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterLdapProtocol {
    #[serde(rename = "LDAP")]
    Ldap,
    #[serde(rename = "LDAPS")]
    Ldaps,
    #[serde(rename = "STARTTLS")]
    Starttls,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterOcspConfiguration {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ocspFunctionality")]
    pub ocsp_functionality: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "queryFrequency")]
    pub query_frequency: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "recoveryFrequency")]
    pub recovery_frequency: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "recoveryMaxTries")]
    pub recovery_max_tries: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "responseTimeout")]
    pub response_timeout: Option<i64>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterOssClusterSettings {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalAccessType")]
    pub external_access_type: Option<RedisEnterpriseClusterOssClusterSettingsExternalAccessType>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "loadBalancer")]
    pub load_balancer: Option<RedisEnterpriseClusterOssClusterSettingsLoadBalancer>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podCIDRs")]
    pub pod_cid_rs: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterOssClusterSettingsExternalAccessType {
    LoadBalancer,
    Disabled,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterOssClusterSettingsLoadBalancer {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalTrafficPolicy")]
    pub external_traffic_policy: Option<RedisEnterpriseClusterOssClusterSettingsLoadBalancerExternalTrafficPolicy>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAnnotations")]
    pub service_annotations: Option<BTreeMap<String, String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterOssClusterSettingsLoadBalancerExternalTrafficPolicy {
    Cluster,
    Local,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPersistentSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enablePersistentVolumeResize")]
    pub enable_persistent_volume_resize: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageClassName")]
    pub storage_class_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeSize")]
    pub volume_size: Option<IntOrString>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinity {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "preferredDuringSchedulingIgnoredDuringExecution")]
    pub preferred_during_scheduling_ignored_during_execution: Option<Vec<RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "requiredDuringSchedulingIgnoredDuringExecution")]
    pub required_during_scheduling_ignored_during_execution: Option<Vec<RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution {
    #[serde(rename = "podAffinityTerm")]
    pub pod_affinity_term: RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm,
    pub weight: i32,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
    pub label_selector: Option<RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
    pub namespace_selector: Option<RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespaces: Option<Vec<String>>,
    #[serde(rename = "topologyKey")]
    pub topology_key: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchExpressions")]
    pub match_expressions: Option<Vec<RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchLabels")]
    pub match_labels: Option<BTreeMap<String, String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions {
    pub key: String,
    pub operator: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub values: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchExpressions")]
    pub match_expressions: Option<Vec<RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchLabels")]
    pub match_labels: Option<BTreeMap<String, String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions {
    pub key: String,
    pub operator: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub values: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
    pub label_selector: Option<RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
    pub namespace_selector: Option<RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespaces: Option<Vec<String>>,
    #[serde(rename = "topologyKey")]
    pub topology_key: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchExpressions")]
    pub match_expressions: Option<Vec<RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchLabels")]
    pub match_labels: Option<BTreeMap<String, String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions {
    pub key: String,
    pub operator: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub values: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchExpressions")]
    pub match_expressions: Option<Vec<RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchLabels")]
    pub match_labels: Option<BTreeMap<String, String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions {
    pub key: String,
    pub operator: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub values: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodStartingPolicy {
    pub enabled: bool,
    #[serde(rename = "startingThresholdSeconds")]
    pub starting_threshold_seconds: i32,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterPodTolerations {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effect: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operator: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tolerationSeconds")]
    pub toleration_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisEnterpriseIpFamily {
    IPv4,
    IPv6,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseImageSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "digestHash")]
    pub digest_hash: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repository: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "versionTag")]
    pub version_tag: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseNodeResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<RedisEnterpriseClusterRedisEnterpriseNodeResourcesClaims>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<BTreeMap<String, IntOrString>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests: Option<BTreeMap<String, IntOrString>>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesConfiguration {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cmServer")]
    pub cm_server: Option<RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCmServer>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "crdbCoordinator")]
    pub crdb_coordinator: Option<RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCrdbCoordinator>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "crdbWorker")]
    pub crdb_worker: Option<RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCrdbWorker>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "mdnsServer")]
    pub mdns_server: Option<RedisEnterpriseClusterRedisEnterpriseServicesConfigurationMdnsServer>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "pdnsServer")]
    pub pdns_server: Option<RedisEnterpriseClusterRedisEnterpriseServicesConfigurationPdnsServer>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub saslauthd: Option<RedisEnterpriseClusterRedisEnterpriseServicesConfigurationSaslauthd>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "statsArchiver")]
    pub stats_archiver: Option<RedisEnterpriseClusterRedisEnterpriseServicesConfigurationStatsArchiver>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCmServer {
    #[serde(rename = "operatingMode")]
    pub operating_mode: RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCmServerOperatingMode,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCmServerOperatingMode {
    #[serde(rename = "enabled")]
    Enabled,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCrdbCoordinator {
    #[serde(rename = "operatingMode")]
    pub operating_mode: RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCrdbCoordinatorOperatingMode,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCrdbCoordinatorOperatingMode {
    #[serde(rename = "enabled")]
    Enabled,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCrdbWorker {
    #[serde(rename = "operatingMode")]
    pub operating_mode: RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCrdbWorkerOperatingMode,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisEnterpriseServicesConfigurationCrdbWorkerOperatingMode {
    #[serde(rename = "enabled")]
    Enabled,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesConfigurationMdnsServer {
    #[serde(rename = "operatingMode")]
    pub operating_mode: RedisEnterpriseClusterRedisEnterpriseServicesConfigurationMdnsServerOperatingMode,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisEnterpriseServicesConfigurationMdnsServerOperatingMode {
    #[serde(rename = "enabled")]
    Enabled,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesConfigurationPdnsServer {
    #[serde(rename = "operatingMode")]
    pub operating_mode: RedisEnterpriseClusterRedisEnterpriseServicesConfigurationPdnsServerOperatingMode,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisEnterpriseServicesConfigurationPdnsServerOperatingMode {
    #[serde(rename = "enabled")]
    Enabled,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesConfigurationSaslauthd {
    #[serde(rename = "operatingMode")]
    pub operating_mode: RedisEnterpriseClusterRedisEnterpriseServicesConfigurationSaslauthdOperatingMode,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisEnterpriseServicesConfigurationSaslauthdOperatingMode {
    #[serde(rename = "enabled")]
    Enabled,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesConfigurationStatsArchiver {
    #[serde(rename = "operatingMode")]
    pub operating_mode: RedisEnterpriseClusterRedisEnterpriseServicesConfigurationStatsArchiverOperatingMode,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisEnterpriseServicesConfigurationStatsArchiverOperatingMode {
    #[serde(rename = "enabled")]
    Enabled,
    #[serde(rename = "disabled")]
    Disabled,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesRiggerImageSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "digestHash")]
    pub digest_hash: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repository: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "versionTag")]
    pub version_tag: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseServicesRiggerResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<RedisEnterpriseClusterRedisEnterpriseServicesRiggerResourcesClaims>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<BTreeMap<String, IntOrString>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests: Option<BTreeMap<String, IntOrString>>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterRedisEnterpriseVolumeMounts {
    #[serde(rename = "mountPath")]
    pub mount_path: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "mountPropagation")]
    pub mount_propagation: Option<String>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPath")]
    pub sub_path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPathExpr")]
    pub sub_path_expr: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterRedisOnFlashSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bigStoreDriver")]
    pub big_store_driver: Option<RedisEnterpriseClusterRedisOnFlashSpecBigStoreDriver>,
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "flashDiskSize")]
    pub flash_disk_size: Option<IntOrString>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "flashStorageEngine")]
    pub flash_storage_engine: Option<RedisEnterpriseClusterRedisOnFlashSpecFlashStorageEngine>,
    #[serde(rename = "storageClassName")]
    pub storage_class_name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisOnFlashSpecBigStoreDriver {
    #[serde(rename = "rocksdb")]
    Rocksdb,
    #[serde(rename = "speedb")]
    Speedb,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisOnFlashSpecFlashStorageEngine {
    #[serde(rename = "rocksdb")]
    Rocksdb,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterRedisUpgradePolicy {
    #[serde(rename = "major")]
    Major,
    #[serde(rename = "latest")]
    Latest,
}

/// The security configuration that will be applied to RS pods.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterSecurityContext {
    /// Policy controlling whether to enable read-only root filesystem for the Redis Enterprise software containers. Note that certain filesystem paths remain writable through mounted volumes to ensure proper functionality.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnlyRootFilesystemPolicy")]
    pub read_only_root_filesystem_policy: Option<RedisEnterpriseClusterSecurityContextReadOnlyRootFilesystemPolicy>,
    /// Settings pertaining to resource limits management by the Redis Enterprise node container.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceLimits")]
    pub resource_limits: Option<RedisEnterpriseClusterSecurityContextResourceLimits>,
}

/// Policy controlling whether to enable read-only root filesystem for the Redis Enterprise software containers. Note that certain filesystem paths remain writable through mounted volumes to ensure proper functionality.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterSecurityContextReadOnlyRootFilesystemPolicy {
    /// Whether to enable read-only root filesystem for the Redis Enterprise software containers. Default is false.
    pub enabled: bool,
}

/// Settings pertaining to resource limits management by the Redis Enterprise node container.
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterSecurityContextResourceLimits {
    /// Allow Redis Enterprise to adjust resource limits, like max open file descriptors, of its data plane processes. When this option is enabled, the SYS_RESOURCE capability is added to the Redis Enterprise pods, and their allowPrivilegeEscalation field is set. Turned off by default.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowAutoAdjustment")]
    pub allow_auto_adjustment: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterServices {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiService")]
    pub api_service: Option<RedisEnterpriseClusterServicesApiService>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "servicesAnnotations")]
    pub services_annotations: Option<BTreeMap<String, String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterServicesApiService {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<RedisEnterpriseClusterServicesApiServiceType>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterServicesApiServiceType {
    #[serde(rename = "ClusterIP")]
    ClusterIp,
    NodePort,
    LoadBalancer,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterServicesRiggerSpec {
    /// databaseServicePortPolicy instructs how to determine the service ports for REDB services. Defaults to DatabasePortForward, if not specified otherwise. Note - Regardless whether this flag is set or not, if an REDB/REAADB configured with databaseServicePort that would be the port exposed by the Service. DatabasePortForward - The service port will be the same as the database port. RedisDefaultPort - The service port will be the default Redis port (6379).
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "databaseServicePortPolicy")]
    pub database_service_port_policy: Option<RedisEnterpriseClusterServicesRiggerSpecDatabaseServicePortPolicy>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "databaseServiceType")]
    pub database_service_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "extraEnvVars")]
    pub extra_env_vars: Option<Vec<RedisEnterpriseClusterServicesRiggerSpecExtraEnvVars>>,
    /// annotations for the service rigger pod
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podAnnotations")]
    pub pod_annotations: Option<BTreeMap<String, String>>,
    /// Used to determine how to name the services created automatically when a database is created. When bdb_name is used, the database name will be also used for the service name. When redis-port is used, the service will be named redis-<port>.
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceNaming")]
    pub service_naming: Option<RedisEnterpriseClusterServicesRiggerSpecServiceNaming>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "servicesRiggerAdditionalPodSpecAttributes")]
    pub services_rigger_additional_pod_spec_attributes: Option<BTreeMap<String, serde_json::Value>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterServicesRiggerSpecDatabaseServicePortPolicy {
    DatabasePortForward,
    RedisDefaultPort,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterServicesRiggerSpecExtraEnvVarsValueFrom {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<RedisEnterpriseClusterServicesRiggerSpecExtraEnvVarsValueFromConfigMapKeyRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<RedisEnterpriseClusterServicesRiggerSpecExtraEnvVarsValueFromFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<RedisEnterpriseClusterServicesRiggerSpecExtraEnvVarsValueFromResourceFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<RedisEnterpriseClusterServicesRiggerSpecExtraEnvVarsValueFromSecretKeyRef>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterServicesRiggerSpecExtraEnvVarsValueFromFieldRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterServicesRiggerSpecExtraEnvVarsValueFromResourceFieldRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    pub resource: String,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterServicesRiggerSpecServiceNaming {
    #[serde(rename = "bdb_name")]
    BdbName,
    #[serde(rename = "redis-port")]
    RedisPort,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterSlaveHa {
    #[serde(rename = "slaveHAGracePeriod")]
    pub slave_ha_grace_period: i32,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterSso {
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforceSSO")]
    pub enforce_sso: Option<bool>,
    pub saml: RedisEnterpriseClusterSsoSaml,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterSsoSaml {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "idpMetadataSecretName")]
    pub idp_metadata_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub issuer: Option<RedisEnterpriseClusterSsoSamlIssuer>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceProvider")]
    pub service_provider: Option<RedisEnterpriseClusterSsoSamlServiceProvider>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "spMetadataSecretName")]
    pub sp_metadata_secret_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterSsoSamlIssuer {
    #[serde(rename = "entityID")]
    pub entity_id: String,
    #[serde(rename = "loginURL")]
    pub login_url: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logoutURL")]
    pub logout_url: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum RedisEnterpriseClusterUiServiceType {
    #[serde(rename = "ClusterIP")]
    ClusterIp,
    NodePort,
    LoadBalancer,
    ExternalName,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUpgradeSpec {
    #[serde(rename = "autoUpgradeRedisEnterprise")]
    pub auto_upgrade_redis_enterprise: bool,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUsageMeter {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "callHomeClient")]
    pub call_home_client: Option<RedisEnterpriseClusterUsageMeterCallHomeClient>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUsageMeterCallHomeClient {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cronExpression")]
    pub cron_expression: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imageSpec")]
    pub image_spec: Option<RedisEnterpriseClusterUsageMeterCallHomeClientImageSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interval: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "proxySecretName")]
    pub proxy_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<RedisEnterpriseClusterUsageMeterCallHomeClientResources>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "s3Target")]
    pub s3_target: Option<RedisEnterpriseClusterUsageMeterCallHomeClientS3Target>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUsageMeterCallHomeClientImageSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "digestHash")]
    pub digest_hash: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repository: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "versionTag")]
    pub version_tag: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUsageMeterCallHomeClientResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<RedisEnterpriseClusterUsageMeterCallHomeClientResourcesClaims>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<BTreeMap<String, IntOrString>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests: Option<BTreeMap<String, IntOrString>>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUsageMeterCallHomeClientS3Target {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bucket: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsSecretName")]
    pub credentials_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prefix: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUserDefinedModulesSource {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub http: Option<RedisEnterpriseClusterUserDefinedModulesSourceHttp>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub https: Option<RedisEnterpriseClusterUserDefinedModulesSourceHttps>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUserDefinedModulesSourceHttp {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsSecret")]
    pub credentials_secret: Option<String>,
    pub url: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterUserDefinedModulesSourceHttps {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsSecret")]
    pub credentials_secret: Option<String>,
    pub url: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumes {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "awsElasticBlockStore")]
    pub aws_elastic_block_store: Option<RedisEnterpriseClusterVolumesAwsElasticBlockStore>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "azureDisk")]
    pub azure_disk: Option<RedisEnterpriseClusterVolumesAzureDisk>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "azureFile")]
    pub azure_file: Option<RedisEnterpriseClusterVolumesAzureFile>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cephfs: Option<RedisEnterpriseClusterVolumesCephfs>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cinder: Option<RedisEnterpriseClusterVolumesCinder>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<RedisEnterpriseClusterVolumesConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub csi: Option<RedisEnterpriseClusterVolumesCsi>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "downwardAPI")]
    pub downward_api: Option<RedisEnterpriseClusterVolumesDownwardApi>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "emptyDir")]
    pub empty_dir: Option<RedisEnterpriseClusterVolumesEmptyDir>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fc: Option<RedisEnterpriseClusterVolumesFc>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "flexVolume")]
    pub flex_volume: Option<RedisEnterpriseClusterVolumesFlexVolume>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub flocker: Option<RedisEnterpriseClusterVolumesFlocker>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gcePersistentDisk")]
    pub gce_persistent_disk: Option<RedisEnterpriseClusterVolumesGcePersistentDisk>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gitRepo")]
    pub git_repo: Option<RedisEnterpriseClusterVolumesGitRepo>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub glusterfs: Option<RedisEnterpriseClusterVolumesGlusterfs>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostPath")]
    pub host_path: Option<RedisEnterpriseClusterVolumesHostPath>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub iscsi: Option<RedisEnterpriseClusterVolumesIscsi>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nfs: Option<RedisEnterpriseClusterVolumesNfs>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "persistentVolumeClaim")]
    pub persistent_volume_claim: Option<RedisEnterpriseClusterVolumesPersistentVolumeClaim>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "photonPersistentDisk")]
    pub photon_persistent_disk: Option<RedisEnterpriseClusterVolumesPhotonPersistentDisk>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "portworxVolume")]
    pub portworx_volume: Option<RedisEnterpriseClusterVolumesPortworxVolume>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub projected: Option<RedisEnterpriseClusterVolumesProjected>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quobyte: Option<RedisEnterpriseClusterVolumesQuobyte>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rbd: Option<RedisEnterpriseClusterVolumesRbd>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "scaleIO")]
    pub scale_io: Option<RedisEnterpriseClusterVolumesScaleIo>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<RedisEnterpriseClusterVolumesSecret>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storageos: Option<RedisEnterpriseClusterVolumesStorageos>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "vsphereVolume")]
    pub vsphere_volume: Option<RedisEnterpriseClusterVolumesVsphereVolume>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesAwsElasticBlockStore {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub partition: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(rename = "volumeID")]
    pub volume_id: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesAzureDisk {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cachingMode")]
    pub caching_mode: Option<String>,
    #[serde(rename = "diskName")]
    pub disk_name: String,
    #[serde(rename = "diskURI")]
    pub disk_uri: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesAzureFile {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(rename = "secretName")]
    pub secret_name: String,
    #[serde(rename = "shareName")]
    pub share_name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesCephfs {
    pub monitors: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretFile")]
    pub secret_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
    pub secret_ref: Option<RedisEnterpriseClusterVolumesCephfsSecretRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesCinder {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
    pub secret_ref: Option<RedisEnterpriseClusterVolumesCinderSecretRef>,
    #[serde(rename = "volumeID")]
    pub volume_id: String,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesConfigMap {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
    pub default_mode: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<RedisEnterpriseClusterVolumesConfigMapItems>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesConfigMapItems {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesCsi {
    pub driver: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodePublishSecretRef")]
    pub node_publish_secret_ref: Option<RedisEnterpriseClusterVolumesCsiNodePublishSecretRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeAttributes")]
    pub volume_attributes: Option<BTreeMap<String, String>>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesDownwardApi {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
    pub default_mode: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<RedisEnterpriseClusterVolumesDownwardApiItems>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesDownwardApiItems {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<RedisEnterpriseClusterVolumesDownwardApiItemsFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<RedisEnterpriseClusterVolumesDownwardApiItemsResourceFieldRef>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesDownwardApiItemsFieldRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesDownwardApiItemsResourceFieldRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    pub resource: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesEmptyDir {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub medium: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sizeLimit")]
    pub size_limit: Option<IntOrString>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesFc {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lun: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "targetWWNs")]
    pub target_ww_ns: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub wwids: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesFlexVolume {
    pub driver: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
    pub secret_ref: Option<RedisEnterpriseClusterVolumesFlexVolumeSecretRef>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesFlocker {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "datasetName")]
    pub dataset_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "datasetUUID")]
    pub dataset_uuid: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesGcePersistentDisk {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub partition: Option<i32>,
    #[serde(rename = "pdName")]
    pub pd_name: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesGlusterfs {
    pub endpoints: String,
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesHostPath {
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesIscsi {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "chapAuthDiscovery")]
    pub chap_auth_discovery: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "chapAuthSession")]
    pub chap_auth_session: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "initiatorName")]
    pub initiator_name: Option<String>,
    pub iqn: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "iscsiInterface")]
    pub iscsi_interface: Option<String>,
    pub lun: i32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub portals: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
    pub secret_ref: Option<RedisEnterpriseClusterVolumesIscsiSecretRef>,
    #[serde(rename = "targetPortal")]
    pub target_portal: String,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesNfs {
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    pub server: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesPersistentVolumeClaim {
    #[serde(rename = "claimName")]
    pub claim_name: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesPhotonPersistentDisk {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(rename = "pdID")]
    pub pd_id: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesPortworxVolume {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(rename = "volumeID")]
    pub volume_id: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjected {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
    pub default_mode: Option<i32>,
    pub sources: Vec<RedisEnterpriseClusterVolumesProjectedSources>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSources {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<RedisEnterpriseClusterVolumesProjectedSourcesConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "downwardAPI")]
    pub downward_api: Option<RedisEnterpriseClusterVolumesProjectedSourcesDownwardApi>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<RedisEnterpriseClusterVolumesProjectedSourcesSecret>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAccountToken")]
    pub service_account_token: Option<RedisEnterpriseClusterVolumesProjectedSourcesServiceAccountToken>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesConfigMap {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<RedisEnterpriseClusterVolumesProjectedSourcesConfigMapItems>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesConfigMapItems {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesDownwardApi {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<RedisEnterpriseClusterVolumesProjectedSourcesDownwardApiItems>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesDownwardApiItems {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<RedisEnterpriseClusterVolumesProjectedSourcesDownwardApiItemsFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<RedisEnterpriseClusterVolumesProjectedSourcesDownwardApiItemsResourceFieldRef>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesDownwardApiItemsFieldRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    #[serde(rename = "fieldPath")]
    pub field_path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesDownwardApiItemsResourceFieldRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
    pub container_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divisor: Option<IntOrString>,
    pub resource: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesSecret {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<RedisEnterpriseClusterVolumesProjectedSourcesSecretItems>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesSecretItems {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesProjectedSourcesServiceAccountToken {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub audience: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "expirationSeconds")]
    pub expiration_seconds: Option<i64>,
    pub path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesQuobyte {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    pub registry: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
    pub volume: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesRbd {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    pub image: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub keyring: Option<String>,
    pub monitors: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pool: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
    pub secret_ref: Option<RedisEnterpriseClusterVolumesRbdSecretRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesScaleIo {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    pub gateway: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "protectionDomain")]
    pub protection_domain: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(rename = "secretRef")]
    pub secret_ref: RedisEnterpriseClusterVolumesScaleIoSecretRef,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sslEnabled")]
    pub ssl_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageMode")]
    pub storage_mode: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storagePool")]
    pub storage_pool: Option<String>,
    pub system: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
    pub volume_name: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesSecret {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
    pub default_mode: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<RedisEnterpriseClusterVolumesSecretItems>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub optional: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretName")]
    pub secret_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesSecretItems {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesStorageos {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
    pub read_only: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
    pub secret_ref: Option<RedisEnterpriseClusterVolumesStorageosSecretRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
    pub volume_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeNamespace")]
    pub volume_namespace: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterVolumesVsphereVolume {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
    pub fs_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storagePolicyID")]
    pub storage_policy_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "storagePolicyName")]
    pub storage_policy_name: Option<String>,
    #[serde(rename = "volumePath")]
    pub volume_path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterStatus {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bundledDatabaseVersions")]
    pub bundled_database_versions: Option<Vec<RedisEnterpriseClusterStatusBundledDatabaseVersions>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "certificatesStatus")]
    pub certificates_status: Option<RedisEnterpriseClusterStatusCertificatesStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clusterCredentialSecretName")]
    pub cluster_credential_secret_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ingressOrRouteMethodStatus")]
    pub ingress_or_route_method_status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "licenseStatus")]
    pub license_status: Option<RedisEnterpriseClusterStatusLicenseStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "managedAPIs")]
    pub managed_ap_is: Option<RedisEnterpriseClusterStatusManagedApIs>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub modules: Option<Vec<RedisEnterpriseClusterStatusModules>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ocspStatus")]
    pub ocsp_status: Option<RedisEnterpriseClusterStatusOcspStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "persistenceStatus")]
    pub persistence_status: Option<RedisEnterpriseClusterStatusPersistenceStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "redisEnterpriseIPFamily")]
    pub redis_enterprise_ip_family: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "specStatus")]
    pub spec_status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterStatusBundledDatabaseVersions {
    #[serde(rename = "dbType")]
    pub db_type: String,
    /// Feature support flags for this database version
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "featureSupport")]
    pub feature_support: Option<RedisEnterpriseClusterStatusBundledDatabaseVersionsFeatureSupport>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub major: Option<bool>,
    pub version: String,
}

/// Feature support flags for this database version
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterStatusBundledDatabaseVersionsFeatureSupport {
    /// Indicates whether this version supports Active-Active (CRDB) databases
    #[serde(rename = "activeActive")]
    pub active_active: bool,
    /// Indicates whether this version supports Redis on Flash (Flex)
    pub flex: bool,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterStatusCertificatesStatus {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub generation: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "updateStatus")]
    pub update_status: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterStatusLicenseStatus {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "activationDate")]
    pub activation_date: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "expirationDate")]
    pub expiration_date: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub features: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "flashShards")]
    pub flash_shards: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "flashShardsLimit")]
    pub flash_shards_limit: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "licenseState")]
    pub license_state: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub owner: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ramShards")]
    pub ram_shards: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ramShardsLimit")]
    pub ram_shards_limit: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "shardsLimit")]
    pub shards_limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "shardsUsage")]
    pub shards_usage: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterStatusManagedApIs {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ldap: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterStatusModules {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "displayName")]
    pub display_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub versions: Option<Vec<String>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
pub struct RedisEnterpriseClusterStatusOcspStatus {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "certStatus")]
    pub cert_status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nextUpdate")]
    pub next_update: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "producedAt")]
    pub produced_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "responderUrl")]
    pub responder_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "revocationTime")]
    pub revocation_time: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "thisUpdate")]
    pub this_update: Option<String>,
}

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