// WARNING: generated by kopium - manual changes will be overwritten
// kopium command: kopium prometheuses.monitoring.coreos.com --derive Default
// kopium version: 0.16.5
//
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Some manual modifications have been made to this file, check the diff carefully when
// regenerating!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

use kube::CustomResource;
use serde::{Serialize, Deserialize};
use std::collections::BTreeMap;
use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
use k8s_openapi::apimachinery::pkg::apis::meta::v1 as metav1;
use schemars::JsonSchema;

#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default)]
#[kube(group = "monitoring.coreos.com", version = "v1", kind = "Prometheus", plural = "prometheuses")]
#[kube(namespaced)]
#[kube(status = "PrometheusStatus")]
#[kube(schema = "disabled")]
pub struct PrometheusSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalAlertManagerConfigs")]
    pub additional_alert_manager_configs: Option<PrometheusAdditionalAlertManagerConfigs>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalAlertRelabelConfigs")]
    pub additional_alert_relabel_configs: Option<PrometheusAdditionalAlertRelabelConfigs>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalArgs")]
    pub additional_args: Option<Vec<PrometheusAdditionalArgs>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalScrapeConfigs")]
    pub additional_scrape_configs: Option<PrometheusAdditionalScrapeConfigs>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub affinity: Option<PrometheusAffinity>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub alerting: Option<PrometheusAlerting>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowOverlappingBlocks")]
    pub allow_overlapping_blocks: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiserverConfig")]
    pub apiserver_config: Option<PrometheusApiserverConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "arbitraryFSAccessThroughSMs")]
    pub arbitrary_fs_access_through_s_ms: Option<PrometheusArbitraryFsAccessThroughSMs>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "baseImage")]
    pub base_image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMaps")]
    pub config_maps: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<PrometheusContainers>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableCompaction")]
    pub disable_compaction: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enableAdminAPI")]
    pub enable_admin_api: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enableFeatures")]
    pub enable_features: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enableRemoteWriteReceiver")]
    pub enable_remote_write_receiver: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedBodySizeLimit")]
    pub enforced_body_size_limit: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedLabelLimit")]
    pub enforced_label_limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedLabelNameLengthLimit")]
    pub enforced_label_name_length_limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedLabelValueLengthLimit")]
    pub enforced_label_value_length_limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedNamespaceLabel")]
    pub enforced_namespace_label: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedSampleLimit")]
    pub enforced_sample_limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedTargetLimit")]
    pub enforced_target_limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "evaluationInterval")]
    pub evaluation_interval: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "excludedFromEnforcement")]
    pub excluded_from_enforcement: Option<Vec<PrometheusExcludedFromEnforcement>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exemplars: Option<PrometheusExemplars>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalLabels")]
    pub external_labels: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalUrl")]
    pub external_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostAliases")]
    pub host_aliases: Option<Vec<PrometheusHostAliases>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostNetwork")]
    pub host_network: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ignoreNamespaceSelectors")]
    pub ignore_namespace_selectors: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
    pub image_pull_policy: Option<PrometheusImagePullPolicy>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullSecrets")]
    pub image_pull_secrets: Option<Vec<PrometheusImagePullSecrets>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "initContainers")]
    pub init_containers: Option<Vec<PrometheusInitContainers>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "listenLocal")]
    pub listen_local: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logFormat")]
    pub log_format: Option<PrometheusLogFormat>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logLevel")]
    pub log_level: Option<PrometheusLogLevel>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "minReadySeconds")]
    pub min_ready_seconds: Option<i32>,
    #[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", rename = "overrideHonorLabels")]
    pub override_honor_labels: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "overrideHonorTimestamps")]
    pub override_honor_timestamps: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub paused: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podMetadata")]
    pub pod_metadata: Option<PrometheusPodMetadata>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podMonitorNamespaceSelector")]
    pub pod_monitor_namespace_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podMonitorSelector")]
    pub pod_monitor_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podTargetLabels")]
    pub pod_target_labels: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "portName")]
    pub port_name: Option<String>,
    #[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 = "probeNamespaceSelector")]
    pub probe_namespace_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "probeSelector")]
    pub probe_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "prometheusExternalLabelName")]
    pub prometheus_external_label_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "prometheusRulesExcludedFromEnforce")]
    pub prometheus_rules_excluded_from_enforce: Option<Vec<PrometheusPrometheusRulesExcludedFromEnforce>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub query: Option<PrometheusQuery>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "queryLogFile")]
    pub query_log_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "remoteRead")]
    pub remote_read: Option<Vec<PrometheusRemoteRead>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "remoteWrite")]
    pub remote_write: Option<Vec<PrometheusRemoteWrite>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "replicaExternalLabelName")]
    pub replica_external_label_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub replicas: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<PrometheusResources>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retention: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "retentionSize")]
    pub retention_size: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "routePrefix")]
    pub route_prefix: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ruleNamespaceSelector")]
    pub rule_namespace_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "ruleSelector")]
    pub rule_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rules: Option<PrometheusRules>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "scrapeConfigNamespaceSelector")]
    pub scrape_config_namespace_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "scrapeConfigSelector")]
    pub scrape_config_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "scrapeInterval")]
    pub scrape_interval: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "scrapeTimeout")]
    pub scrape_timeout: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secrets: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<PrometheusSecurityContext>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAccountName")]
    pub service_account_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceMonitorNamespaceSelector")]
    pub service_monitor_namespace_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceMonitorSelector")]
    pub service_monitor_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sha: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shards: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage: Option<PrometheusStorage>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thanos: Option<PrometheusThanos>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tolerations: Option<Vec<PrometheusTolerations>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "topologySpreadConstraints")]
    pub topology_spread_constraints: Option<Vec<PrometheusTopologySpreadConstraints>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tracingConfig")]
    pub tracing_config: Option<PrometheusTracingConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tsdb: Option<PrometheusTsdb>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
    pub volume_mounts: Option<Vec<PrometheusVolumeMounts>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub volumes: Option<Vec<PrometheusVolumes>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "walCompression")]
    pub wal_compression: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub web: Option<PrometheusWeb>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAdditionalAlertManagerConfigs {
    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)]
pub struct PrometheusAdditionalAlertRelabelConfigs {
    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)]
pub struct PrometheusAdditionalArgs {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAdditionalScrapeConfigs {
    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)]
pub struct PrometheusAffinity {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeAffinity")]
    pub node_affinity: Option<PrometheusAffinityNodeAffinity>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podAffinity")]
    pub pod_affinity: Option<PrometheusAffinityPodAffinity>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "podAntiAffinity")]
    pub pod_anti_affinity: Option<PrometheusAffinityPodAntiAffinity>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution {
    pub preference: PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference,
    pub weight: i32,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchExpressions")]
    pub match_expressions: Option<Vec<PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchFields")]
    pub match_fields: Option<Vec<PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions {
    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)]
pub struct PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields {
    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)]
pub struct PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    #[serde(rename = "nodeSelectorTerms")]
    pub node_selector_terms: Vec<PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchExpressions")]
    pub match_expressions: Option<Vec<PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchFields")]
    pub match_fields: Option<Vec<PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions {
    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)]
pub struct PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields {
    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)]
pub struct PrometheusAffinityPodAffinity {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "preferredDuringSchedulingIgnoredDuringExecution")]
    pub preferred_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "requiredDuringSchedulingIgnoredDuringExecution")]
    pub required_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution>>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
    pub label_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
    pub namespace_selector: Option<metav1::LabelSelector>,
    #[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)]
pub struct PrometheusAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
    pub label_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
    pub namespace_selector: Option<metav1::LabelSelector>,
    #[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)]
pub struct PrometheusAffinityPodAntiAffinity {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "preferredDuringSchedulingIgnoredDuringExecution")]
    pub preferred_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "requiredDuringSchedulingIgnoredDuringExecution")]
    pub required_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution>>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
    pub label_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
    pub namespace_selector: Option<metav1::LabelSelector>,
    #[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)]
pub struct PrometheusAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
    pub label_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
    pub namespace_selector: Option<metav1::LabelSelector>,
    #[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)]
pub struct PrometheusAlerting {
    pub alertmanagers: Vec<PrometheusAlertingAlertmanagers>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAlertingAlertmanagers {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub authorization: Option<PrometheusAlertingAlertmanagersAuthorization>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "basicAuth")]
    pub basic_auth: Option<PrometheusAlertingAlertmanagersBasicAuth>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerTokenFile")]
    pub bearer_token_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "enableHttp2")]
    pub enable_http2: Option<bool>,
    pub name: String,
    pub namespace: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "pathPrefix")]
    pub path_prefix: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
    pub tls_config: Option<PrometheusAlertingAlertmanagersTlsConfig>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAlertingAlertmanagersAuthorizationCredentials {
    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)]
pub struct PrometheusAlertingAlertmanagersBasicAuth {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub password: Option<PrometheusAlertingAlertmanagersBasicAuthPassword>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub username: Option<PrometheusAlertingAlertmanagersBasicAuthUsername>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAlertingAlertmanagersBasicAuthPassword {
    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)]
pub struct PrometheusAlertingAlertmanagersBasicAuthUsername {
    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)]
pub struct PrometheusAlertingAlertmanagersTlsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ca: Option<PrometheusAlertingAlertmanagersTlsConfigCa>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
    pub ca_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<PrometheusAlertingAlertmanagersTlsConfigCert>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
    pub cert_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
    pub insecure_skip_verify: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
    pub key_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
    pub key_secret: Option<PrometheusAlertingAlertmanagersTlsConfigKeySecret>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
    pub server_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAlertingAlertmanagersTlsConfigCa {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusAlertingAlertmanagersTlsConfigCaConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusAlertingAlertmanagersTlsConfigCaSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAlertingAlertmanagersTlsConfigCaConfigMap {
    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)]
pub struct PrometheusAlertingAlertmanagersTlsConfigCaSecret {
    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)]
pub struct PrometheusAlertingAlertmanagersTlsConfigCert {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusAlertingAlertmanagersTlsConfigCertConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusAlertingAlertmanagersTlsConfigCertSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusAlertingAlertmanagersTlsConfigCertConfigMap {
    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)]
pub struct PrometheusAlertingAlertmanagersTlsConfigCertSecret {
    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)]
pub struct PrometheusAlertingAlertmanagersTlsConfigKeySecret {
    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)]
pub struct PrometheusApiserverConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub authorization: Option<PrometheusApiserverConfigAuthorization>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "basicAuth")]
    pub basic_auth: Option<PrometheusApiserverConfigBasicAuth>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerToken")]
    pub bearer_token: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerTokenFile")]
    pub bearer_token_file: Option<String>,
    pub host: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
    pub tls_config: Option<PrometheusApiserverConfigTlsConfig>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusApiserverConfigAuthorization {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub credentials: Option<PrometheusApiserverConfigAuthorizationCredentials>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsFile")]
    pub credentials_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusApiserverConfigAuthorizationCredentials {
    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)]
pub struct PrometheusApiserverConfigBasicAuth {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub password: Option<PrometheusApiserverConfigBasicAuthPassword>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub username: Option<PrometheusApiserverConfigBasicAuthUsername>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusApiserverConfigBasicAuthPassword {
    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)]
pub struct PrometheusApiserverConfigBasicAuthUsername {
    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)]
pub struct PrometheusApiserverConfigTlsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ca: Option<PrometheusApiserverConfigTlsConfigCa>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
    pub ca_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<PrometheusApiserverConfigTlsConfigCert>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
    pub cert_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
    pub insecure_skip_verify: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
    pub key_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
    pub key_secret: Option<PrometheusApiserverConfigTlsConfigKeySecret>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
    pub server_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusApiserverConfigTlsConfigCa {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusApiserverConfigTlsConfigCaConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusApiserverConfigTlsConfigCaSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusApiserverConfigTlsConfigCaConfigMap {
    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)]
pub struct PrometheusApiserverConfigTlsConfigCaSecret {
    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)]
pub struct PrometheusApiserverConfigTlsConfigCert {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusApiserverConfigTlsConfigCertConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusApiserverConfigTlsConfigCertSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusApiserverConfigTlsConfigCertConfigMap {
    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)]
pub struct PrometheusApiserverConfigTlsConfigCertSecret {
    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)]
pub struct PrometheusApiserverConfigTlsConfigKeySecret {
    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)]
pub struct PrometheusArbitraryFsAccessThroughSMs {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deny: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainers {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<PrometheusContainersEnv>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "envFrom")]
    pub env_from: Option<Vec<PrometheusContainersEnvFrom>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: 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 lifecycle: Option<PrometheusContainersLifecycle>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "livenessProbe")]
    pub liveness_probe: Option<PrometheusContainersLivenessProbe>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ports: Option<Vec<PrometheusContainersPorts>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readinessProbe")]
    pub readiness_probe: Option<PrometheusContainersReadinessProbe>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resizePolicy")]
    pub resize_policy: Option<Vec<PrometheusContainersResizePolicy>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<PrometheusContainersResources>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<PrometheusContainersSecurityContext>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "startupProbe")]
    pub startup_probe: Option<PrometheusContainersStartupProbe>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stdin: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "stdinOnce")]
    pub stdin_once: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationMessagePath")]
    pub termination_message_path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationMessagePolicy")]
    pub termination_message_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tty: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeDevices")]
    pub volume_devices: Option<Vec<PrometheusContainersVolumeDevices>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
    pub volume_mounts: Option<Vec<PrometheusContainersVolumeMounts>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "workingDir")]
    pub working_dir: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersEnv {
    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<PrometheusContainersEnvValueFrom>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersEnvValueFrom {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<PrometheusContainersEnvValueFromConfigMapKeyRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<PrometheusContainersEnvValueFromFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<PrometheusContainersEnvValueFromResourceFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<PrometheusContainersEnvValueFromSecretKeyRef>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersEnvValueFromConfigMapKeyRef {
    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)]
pub struct PrometheusContainersEnvValueFromFieldRef {
    #[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)]
pub struct PrometheusContainersEnvValueFromResourceFieldRef {
    #[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)]
pub struct PrometheusContainersEnvValueFromSecretKeyRef {
    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)]
pub struct PrometheusContainersEnvFrom {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapRef")]
    pub config_map_ref: Option<PrometheusContainersEnvFromConfigMapRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prefix: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
    pub secret_ref: Option<PrometheusContainersEnvFromSecretRef>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersEnvFromConfigMapRef {
    #[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)]
pub struct PrometheusContainersEnvFromSecretRef {
    #[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)]
pub struct PrometheusContainersLifecycle {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "postStart")]
    pub post_start: Option<PrometheusContainersLifecyclePostStart>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "preStop")]
    pub pre_stop: Option<PrometheusContainersLifecyclePreStop>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersLifecyclePostStart {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusContainersLifecyclePostStartExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusContainersLifecyclePostStartHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusContainersLifecyclePostStartTcpSocket>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersLifecyclePostStartHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusContainersLifecyclePostStartHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersLifecyclePreStop {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusContainersLifecyclePreStopExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusContainersLifecyclePreStopHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusContainersLifecyclePreStopTcpSocket>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersLifecyclePreStopHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusContainersLifecyclePreStopHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersLivenessProbe {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusContainersLivenessProbeExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
    pub failure_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grpc: Option<PrometheusContainersLivenessProbeGrpc>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusContainersLivenessProbeHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
    pub initial_delay_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
    pub period_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
    pub success_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusContainersLivenessProbeTcpSocket>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
    pub termination_grace_period_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
    pub timeout_seconds: Option<i32>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersLivenessProbeHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusContainersLivenessProbeHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersPorts {
    #[serde(rename = "containerPort")]
    pub container_port: i32,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostIP")]
    pub host_ip: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostPort")]
    pub host_port: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersReadinessProbe {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusContainersReadinessProbeExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
    pub failure_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grpc: Option<PrometheusContainersReadinessProbeGrpc>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusContainersReadinessProbeHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
    pub initial_delay_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
    pub period_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
    pub success_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusContainersReadinessProbeTcpSocket>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
    pub termination_grace_period_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
    pub timeout_seconds: Option<i32>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersReadinessProbeHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusContainersReadinessProbeHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersResizePolicy {
    #[serde(rename = "resourceName")]
    pub resource_name: String,
    #[serde(rename = "restartPolicy")]
    pub restart_policy: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<PrometheusContainersResourcesClaims>>,
    #[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)]
pub struct PrometheusContainersResourcesClaims {
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersSecurityContext {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowPrivilegeEscalation")]
    pub allow_privilege_escalation: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<PrometheusContainersSecurityContextCapabilities>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub privileged: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "procMount")]
    pub proc_mount: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnlyRootFilesystem")]
    pub read_only_root_filesystem: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
    pub run_as_group: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
    pub run_as_non_root: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
    pub se_linux_options: Option<PrometheusContainersSecurityContextSeLinuxOptions>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
    pub seccomp_profile: Option<PrometheusContainersSecurityContextSeccompProfile>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
    pub windows_options: Option<PrometheusContainersSecurityContextWindowsOptions>,
}

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

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersSecurityContextWindowsOptions {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
    pub gmsa_credential_spec: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
    pub gmsa_credential_spec_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
    pub host_process: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
    pub run_as_user_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersStartupProbe {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusContainersStartupProbeExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
    pub failure_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grpc: Option<PrometheusContainersStartupProbeGrpc>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusContainersStartupProbeHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
    pub initial_delay_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
    pub period_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
    pub success_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusContainersStartupProbeTcpSocket>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
    pub termination_grace_period_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
    pub timeout_seconds: Option<i32>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersStartupProbeHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusContainersStartupProbeHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersVolumeDevices {
    #[serde(rename = "devicePath")]
    pub device_path: String,
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusContainersVolumeMounts {
    #[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)]
pub struct PrometheusExcludedFromEnforcement {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub group: Option<PrometheusExcludedFromEnforcementGroup>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub namespace: String,
    pub resource: String,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum PrometheusExcludedFromEnforcementGroup {
    #[serde(rename = "monitoring.coreos.com")]
    MonitoringCoreosCom,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusExemplars {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxSize")]
    pub max_size: Option<i64>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusHostAliases {
    pub hostnames: Vec<String>,
    pub ip: String,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum PrometheusImagePullPolicy {
    #[serde(rename = "")]
    KopiumEmpty,
    Always,
    Never,
    IfNotPresent,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainers {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<PrometheusInitContainersEnv>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "envFrom")]
    pub env_from: Option<Vec<PrometheusInitContainersEnvFrom>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: 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 lifecycle: Option<PrometheusInitContainersLifecycle>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "livenessProbe")]
    pub liveness_probe: Option<PrometheusInitContainersLivenessProbe>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ports: Option<Vec<PrometheusInitContainersPorts>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readinessProbe")]
    pub readiness_probe: Option<PrometheusInitContainersReadinessProbe>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resizePolicy")]
    pub resize_policy: Option<Vec<PrometheusInitContainersResizePolicy>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<PrometheusInitContainersResources>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
    pub security_context: Option<PrometheusInitContainersSecurityContext>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "startupProbe")]
    pub startup_probe: Option<PrometheusInitContainersStartupProbe>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stdin: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "stdinOnce")]
    pub stdin_once: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationMessagePath")]
    pub termination_message_path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationMessagePolicy")]
    pub termination_message_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tty: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeDevices")]
    pub volume_devices: Option<Vec<PrometheusInitContainersVolumeDevices>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
    pub volume_mounts: Option<Vec<PrometheusInitContainersVolumeMounts>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "workingDir")]
    pub working_dir: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersEnv {
    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<PrometheusInitContainersEnvValueFrom>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersEnvValueFrom {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
    pub config_map_key_ref: Option<PrometheusInitContainersEnvValueFromConfigMapKeyRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<PrometheusInitContainersEnvValueFromFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
    pub resource_field_ref: Option<PrometheusInitContainersEnvValueFromResourceFieldRef>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
    pub secret_key_ref: Option<PrometheusInitContainersEnvValueFromSecretKeyRef>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersEnvValueFromConfigMapKeyRef {
    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)]
pub struct PrometheusInitContainersEnvValueFromFieldRef {
    #[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)]
pub struct PrometheusInitContainersEnvValueFromResourceFieldRef {
    #[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)]
pub struct PrometheusInitContainersEnvValueFromSecretKeyRef {
    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)]
pub struct PrometheusInitContainersEnvFrom {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapRef")]
    pub config_map_ref: Option<PrometheusInitContainersEnvFromConfigMapRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prefix: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
    pub secret_ref: Option<PrometheusInitContainersEnvFromSecretRef>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersEnvFromConfigMapRef {
    #[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)]
pub struct PrometheusInitContainersEnvFromSecretRef {
    #[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)]
pub struct PrometheusInitContainersLifecycle {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "postStart")]
    pub post_start: Option<PrometheusInitContainersLifecyclePostStart>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "preStop")]
    pub pre_stop: Option<PrometheusInitContainersLifecyclePreStop>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersLifecyclePostStart {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusInitContainersLifecyclePostStartExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusInitContainersLifecyclePostStartHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusInitContainersLifecyclePostStartTcpSocket>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersLifecyclePostStartHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusInitContainersLifecyclePostStartHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersLifecyclePreStop {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusInitContainersLifecyclePreStopExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusInitContainersLifecyclePreStopHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusInitContainersLifecyclePreStopTcpSocket>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersLifecyclePreStopHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusInitContainersLifecyclePreStopHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersLivenessProbe {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusInitContainersLivenessProbeExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
    pub failure_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grpc: Option<PrometheusInitContainersLivenessProbeGrpc>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusInitContainersLivenessProbeHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
    pub initial_delay_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
    pub period_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
    pub success_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusInitContainersLivenessProbeTcpSocket>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
    pub termination_grace_period_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
    pub timeout_seconds: Option<i32>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersLivenessProbeHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusInitContainersLivenessProbeHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersPorts {
    #[serde(rename = "containerPort")]
    pub container_port: i32,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostIP")]
    pub host_ip: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostPort")]
    pub host_port: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersReadinessProbe {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusInitContainersReadinessProbeExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
    pub failure_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grpc: Option<PrometheusInitContainersReadinessProbeGrpc>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusInitContainersReadinessProbeHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
    pub initial_delay_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
    pub period_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
    pub success_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusInitContainersReadinessProbeTcpSocket>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
    pub termination_grace_period_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
    pub timeout_seconds: Option<i32>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersReadinessProbeHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusInitContainersReadinessProbeHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersResizePolicy {
    #[serde(rename = "resourceName")]
    pub resource_name: String,
    #[serde(rename = "restartPolicy")]
    pub restart_policy: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<PrometheusInitContainersResourcesClaims>>,
    #[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)]
pub struct PrometheusInitContainersResourcesClaims {
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersSecurityContext {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowPrivilegeEscalation")]
    pub allow_privilege_escalation: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<PrometheusInitContainersSecurityContextCapabilities>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub privileged: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "procMount")]
    pub proc_mount: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnlyRootFilesystem")]
    pub read_only_root_filesystem: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
    pub run_as_group: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
    pub run_as_non_root: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
    pub se_linux_options: Option<PrometheusInitContainersSecurityContextSeLinuxOptions>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
    pub seccomp_profile: Option<PrometheusInitContainersSecurityContextSeccompProfile>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
    pub windows_options: Option<PrometheusInitContainersSecurityContextWindowsOptions>,
}

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

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersSecurityContextWindowsOptions {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
    pub gmsa_credential_spec: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
    pub gmsa_credential_spec_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
    pub host_process: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
    pub run_as_user_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersStartupProbe {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exec: Option<PrometheusInitContainersStartupProbeExec>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
    pub failure_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grpc: Option<PrometheusInitContainersStartupProbeGrpc>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
    pub http_get: Option<PrometheusInitContainersStartupProbeHttpGet>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
    pub initial_delay_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
    pub period_seconds: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
    pub success_threshold: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
    pub tcp_socket: Option<PrometheusInitContainersStartupProbeTcpSocket>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
    pub termination_grace_period_seconds: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
    pub timeout_seconds: Option<i32>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersStartupProbeHttpGet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
    pub http_headers: Option<Vec<PrometheusInitContainersStartupProbeHttpGetHttpHeaders>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    pub port: IntOrString,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
}

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersVolumeDevices {
    #[serde(rename = "devicePath")]
    pub device_path: String,
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusInitContainersVolumeMounts {
    #[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)]
pub enum PrometheusLogFormat {
    #[serde(rename = "")]
    KopiumEmpty,
    #[serde(rename = "logfmt")]
    Logfmt,
    #[serde(rename = "json")]
    Json,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum PrometheusLogLevel {
    #[serde(rename = "")]
    KopiumEmpty,
    #[serde(rename = "debug")]
    Debug,
    #[serde(rename = "info")]
    Info,
    #[serde(rename = "warn")]
    Warn,
    #[serde(rename = "error")]
    Error,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusPrometheusRulesExcludedFromEnforce {
    #[serde(rename = "ruleName")]
    pub rule_name: String,
    #[serde(rename = "ruleNamespace")]
    pub rule_namespace: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusQuery {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "lookbackDelta")]
    pub lookback_delta: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxConcurrency")]
    pub max_concurrency: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxSamples")]
    pub max_samples: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteRead {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub authorization: Option<PrometheusRemoteReadAuthorization>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "basicAuth")]
    pub basic_auth: Option<PrometheusRemoteReadBasicAuth>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerToken")]
    pub bearer_token: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerTokenFile")]
    pub bearer_token_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "filterExternalLabels")]
    pub filter_external_labels: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "followRedirects")]
    pub follow_redirects: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub oauth2: Option<PrometheusRemoteReadOauth2>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "proxyUrl")]
    pub proxy_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readRecent")]
    pub read_recent: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "remoteTimeout")]
    pub remote_timeout: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "requiredMatchers")]
    pub required_matchers: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
    pub tls_config: Option<PrometheusRemoteReadTlsConfig>,
    pub url: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteReadAuthorization {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub credentials: Option<PrometheusRemoteReadAuthorizationCredentials>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsFile")]
    pub credentials_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteReadAuthorizationCredentials {
    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)]
pub struct PrometheusRemoteReadBasicAuth {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub password: Option<PrometheusRemoteReadBasicAuthPassword>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub username: Option<PrometheusRemoteReadBasicAuthUsername>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteReadBasicAuthPassword {
    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)]
pub struct PrometheusRemoteReadBasicAuthUsername {
    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)]
pub struct PrometheusRemoteReadOauth2 {
    #[serde(rename = "clientId")]
    pub client_id: PrometheusRemoteReadOauth2ClientId,
    #[serde(rename = "clientSecret")]
    pub client_secret: PrometheusRemoteReadOauth2ClientSecret,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "endpointParams")]
    pub endpoint_params: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
    #[serde(rename = "tokenUrl")]
    pub token_url: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteReadOauth2ClientId {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusRemoteReadOauth2ClientIdConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusRemoteReadOauth2ClientIdSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteReadOauth2ClientIdConfigMap {
    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)]
pub struct PrometheusRemoteReadOauth2ClientIdSecret {
    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)]
pub struct PrometheusRemoteReadOauth2ClientSecret {
    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)]
pub struct PrometheusRemoteReadTlsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ca: Option<PrometheusRemoteReadTlsConfigCa>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
    pub ca_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<PrometheusRemoteReadTlsConfigCert>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
    pub cert_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
    pub insecure_skip_verify: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
    pub key_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
    pub key_secret: Option<PrometheusRemoteReadTlsConfigKeySecret>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
    pub server_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteReadTlsConfigCa {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusRemoteReadTlsConfigCaConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusRemoteReadTlsConfigCaSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteReadTlsConfigCaConfigMap {
    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)]
pub struct PrometheusRemoteReadTlsConfigCaSecret {
    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)]
pub struct PrometheusRemoteReadTlsConfigCert {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusRemoteReadTlsConfigCertConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusRemoteReadTlsConfigCertSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRemoteReadTlsConfigCertConfigMap {
    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)]
pub struct PrometheusRemoteReadTlsConfigCertSecret {
    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)]
pub struct PrometheusRemoteReadTlsConfigKeySecret {
    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, JsonSchema)]
pub struct PrometheusRemoteWrite {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub authorization: Option<PrometheusRemoteWriteAuthorization>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "basicAuth")]
    pub basic_auth: Option<PrometheusRemoteWriteBasicAuth>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerToken")]
    pub bearer_token: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerTokenFile")]
    pub bearer_token_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "metadataConfig")]
    pub metadata_config: Option<PrometheusRemoteWriteMetadataConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub oauth2: Option<PrometheusRemoteWriteOauth2>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "proxyUrl")]
    pub proxy_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "queueConfig")]
    pub queue_config: Option<PrometheusRemoteWriteQueueConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "remoteTimeout")]
    pub remote_timeout: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sendExemplars")]
    pub send_exemplars: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sendNativeHistograms")]
    pub send_native_histograms: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sigv4: Option<PrometheusRemoteWriteSigv4>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
    pub tls_config: Option<PrometheusRemoteWriteTlsConfig>,
    pub url: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "writeRelabelConfigs")]
    pub write_relabel_configs: Option<Vec<PrometheusRemoteWriteWriteRelabelConfigs>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteAuthorization {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub credentials: Option<PrometheusRemoteWriteAuthorizationCredentials>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsFile")]
    pub credentials_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteAuthorizationCredentials {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteBasicAuth {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub password: Option<PrometheusRemoteWriteBasicAuthPassword>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub username: Option<PrometheusRemoteWriteBasicAuthUsername>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteBasicAuthPassword {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteBasicAuthUsername {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteMetadataConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub send: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sendInterval")]
    pub send_interval: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteOauth2 {
    #[serde(rename = "clientId")]
    pub client_id: PrometheusRemoteWriteOauth2ClientId,
    #[serde(rename = "clientSecret")]
    pub client_secret: PrometheusRemoteWriteOauth2ClientSecret,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "endpointParams")]
    pub endpoint_params: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
    #[serde(rename = "tokenUrl")]
    pub token_url: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteOauth2ClientId {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusRemoteWriteOauth2ClientIdConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusRemoteWriteOauth2ClientIdSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteOauth2ClientIdConfigMap {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteOauth2ClientIdSecret {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteOauth2ClientSecret {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteQueueConfig {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "batchSendDeadline")]
    pub batch_send_deadline: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capacity: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxBackoff")]
    pub max_backoff: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxRetries")]
    pub max_retries: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxSamplesPerSend")]
    pub max_samples_per_send: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxShards")]
    pub max_shards: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "minBackoff")]
    pub min_backoff: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "minShards")]
    pub min_shards: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "retryOnRateLimit")]
    pub retry_on_rate_limit: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteSigv4 {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessKey")]
    pub access_key: Option<PrometheusRemoteWriteSigv4AccessKey>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub profile: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "roleArn")]
    pub role_arn: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKey")]
    pub secret_key: Option<PrometheusRemoteWriteSigv4SecretKey>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteSigv4AccessKey {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteSigv4SecretKey {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteTlsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ca: Option<PrometheusRemoteWriteTlsConfigCa>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
    pub ca_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<PrometheusRemoteWriteTlsConfigCert>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
    pub cert_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
    pub insecure_skip_verify: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
    pub key_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
    pub key_secret: Option<PrometheusRemoteWriteTlsConfigKeySecret>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
    pub server_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteTlsConfigCa {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusRemoteWriteTlsConfigCaConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusRemoteWriteTlsConfigCaSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteTlsConfigCaConfigMap {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteTlsConfigCaSecret {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteTlsConfigCert {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusRemoteWriteTlsConfigCertConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusRemoteWriteTlsConfigCertSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
pub struct PrometheusRemoteWriteTlsConfigCertConfigMap {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteTlsConfigCertSecret {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteTlsConfigKeySecret {
    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, JsonSchema)]
pub struct PrometheusRemoteWriteWriteRelabelConfigs {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<PrometheusRemoteWriteWriteRelabelConfigsAction>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub modulus: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub regex: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub replacement: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub separator: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "sourceLabels")]
    pub source_labels: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "targetLabel")]
    pub target_label: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema)]
pub enum PrometheusRemoteWriteWriteRelabelConfigsAction {
    #[serde(rename = "replace")]
    Replace,
    #[serde(rename = "keep")]
    Keep,
    #[serde(rename = "drop")]
    Drop,
    #[serde(rename = "hashmod")]
    HashMod,
    #[serde(rename = "labelmap")]
    LabelMap,
    #[serde(rename = "labeldrop")]
    LabelDrop,
    #[serde(rename = "labelkeep")]
    LabelKeep,
    #[serde(rename = "lowercase")]
    Lowercase,
    #[serde(rename = "uppercase")]
    Uppercase,
    #[serde(rename = "keepequal")]
    KeepEqual,
    #[serde(rename = "dropequal")]
    DropEqual,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<PrometheusResourcesClaims>>,
    #[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)]
pub struct PrometheusResourcesClaims {
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRules {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub alert: Option<PrometheusRulesAlert>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusRulesAlert {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "forGracePeriod")]
    pub for_grace_period: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "forOutageTolerance")]
    pub for_outage_tolerance: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resendDelay")]
    pub resend_delay: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusSecurityContext {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroup")]
    pub fs_group: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroupChangePolicy")]
    pub fs_group_change_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
    pub run_as_group: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
    pub run_as_non_root: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
    pub run_as_user: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
    pub se_linux_options: Option<PrometheusSecurityContextSeLinuxOptions>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
    pub seccomp_profile: Option<PrometheusSecurityContextSeccompProfile>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "supplementalGroups")]
    pub supplemental_groups: Option<Vec<i64>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sysctls: Option<Vec<PrometheusSecurityContextSysctls>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
    pub windows_options: Option<PrometheusSecurityContextWindowsOptions>,
}

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

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

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusSecurityContextWindowsOptions {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
    pub gmsa_credential_spec: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
    pub gmsa_credential_spec_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
    pub host_process: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
    pub run_as_user_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorage {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableMountSubPath")]
    pub disable_mount_sub_path: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "emptyDir")]
    pub empty_dir: Option<PrometheusStorageEmptyDir>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ephemeral: Option<PrometheusStorageEphemeral>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeClaimTemplate")]
    pub volume_claim_template: Option<PrometheusStorageVolumeClaimTemplate>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageEmptyDir {
    #[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)]
pub struct PrometheusStorageEphemeral {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeClaimTemplate")]
    pub volume_claim_template: Option<PrometheusStorageEphemeralVolumeClaimTemplate>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageEphemeralVolumeClaimTemplate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<PrometheusStorageEphemeralVolumeClaimTemplateMetadata>,
    pub spec: PrometheusStorageEphemeralVolumeClaimTemplateSpec,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessModes")]
    pub access_modes: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSource")]
    pub data_source: Option<PrometheusStorageEphemeralVolumeClaimTemplateSpecDataSource>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSourceRef")]
    pub data_source_ref: Option<PrometheusStorageEphemeralVolumeClaimTemplateSpecDataSourceRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<PrometheusStorageEphemeralVolumeClaimTemplateSpecResources>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub selector: Option<metav1::LabelSelector>,
    #[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 = "volumeMode")]
    pub volume_mode: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
    pub volume_name: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpecDataSourceRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
    pub api_group: Option<String>,
    pub kind: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpecResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<PrometheusStorageEphemeralVolumeClaimTemplateSpecResourcesClaims>>,
    #[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)]
pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpecResourcesClaims {
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageVolumeClaimTemplate {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
    pub api_version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<PrometheusStorageVolumeClaimTemplateMetadata>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spec: Option<PrometheusStorageVolumeClaimTemplateSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<PrometheusStorageVolumeClaimTemplateStatus>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageVolumeClaimTemplateSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessModes")]
    pub access_modes: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSource")]
    pub data_source: Option<PrometheusStorageVolumeClaimTemplateSpecDataSource>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSourceRef")]
    pub data_source_ref: Option<PrometheusStorageVolumeClaimTemplateSpecDataSourceRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<PrometheusStorageVolumeClaimTemplateSpecResources>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub selector: Option<metav1::LabelSelector>,
    #[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 = "volumeMode")]
    pub volume_mode: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
    pub volume_name: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageVolumeClaimTemplateSpecDataSourceRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
    pub api_group: Option<String>,
    pub kind: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageVolumeClaimTemplateSpecResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<PrometheusStorageVolumeClaimTemplateSpecResourcesClaims>>,
    #[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)]
pub struct PrometheusStorageVolumeClaimTemplateSpecResourcesClaims {
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageVolumeClaimTemplateStatus {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessModes")]
    pub access_modes: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "allocatedResources")]
    pub allocated_resources: Option<BTreeMap<String, IntOrString>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capacity: Option<BTreeMap<String, IntOrString>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conditions: Option<Vec<PrometheusStorageVolumeClaimTemplateStatusConditions>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub phase: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "resizeStatus")]
    pub resize_status: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStorageVolumeClaimTemplateStatusConditions {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "lastProbeTime")]
    pub last_probe_time: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "lastTransitionTime")]
    pub last_transition_time: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    pub status: String,
    #[serde(rename = "type")]
    pub r#type: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusThanos {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalArgs")]
    pub additional_args: Option<Vec<PrometheusThanosAdditionalArgs>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "baseImage")]
    pub base_image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "blockSize")]
    pub block_size: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "getConfigInterval")]
    pub get_config_interval: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "getConfigTimeout")]
    pub get_config_timeout: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "grpcListenLocal")]
    pub grpc_listen_local: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "grpcServerTlsConfig")]
    pub grpc_server_tls_config: Option<PrometheusThanosGrpcServerTlsConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpListenLocal")]
    pub http_listen_local: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "listenLocal")]
    pub listen_local: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logFormat")]
    pub log_format: Option<PrometheusThanosLogFormat>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "logLevel")]
    pub log_level: Option<PrometheusThanosLogLevel>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "minTime")]
    pub min_time: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "objectStorageConfig")]
    pub object_storage_config: Option<PrometheusThanosObjectStorageConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "objectStorageConfigFile")]
    pub object_storage_config_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "readyTimeout")]
    pub ready_timeout: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<PrometheusThanosResources>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sha: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tracingConfig")]
    pub tracing_config: Option<PrometheusThanosTracingConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tracingConfigFile")]
    pub tracing_config_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
    pub volume_mounts: Option<Vec<PrometheusThanosVolumeMounts>>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusThanosGrpcServerTlsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ca: Option<PrometheusThanosGrpcServerTlsConfigCa>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
    pub ca_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<PrometheusThanosGrpcServerTlsConfigCert>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
    pub cert_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
    pub insecure_skip_verify: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
    pub key_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
    pub key_secret: Option<PrometheusThanosGrpcServerTlsConfigKeySecret>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
    pub server_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusThanosGrpcServerTlsConfigCa {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusThanosGrpcServerTlsConfigCaConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusThanosGrpcServerTlsConfigCaSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusThanosGrpcServerTlsConfigCaConfigMap {
    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)]
pub struct PrometheusThanosGrpcServerTlsConfigCaSecret {
    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)]
pub struct PrometheusThanosGrpcServerTlsConfigCert {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusThanosGrpcServerTlsConfigCertConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusThanosGrpcServerTlsConfigCertSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusThanosGrpcServerTlsConfigCertConfigMap {
    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)]
pub struct PrometheusThanosGrpcServerTlsConfigCertSecret {
    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)]
pub struct PrometheusThanosGrpcServerTlsConfigKeySecret {
    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)]
pub enum PrometheusThanosLogFormat {
    #[serde(rename = "")]
    KopiumEmpty,
    #[serde(rename = "logfmt")]
    Logfmt,
    #[serde(rename = "json")]
    Json,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum PrometheusThanosLogLevel {
    #[serde(rename = "")]
    KopiumEmpty,
    #[serde(rename = "debug")]
    Debug,
    #[serde(rename = "info")]
    Info,
    #[serde(rename = "warn")]
    Warn,
    #[serde(rename = "error")]
    Error,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusThanosObjectStorageConfig {
    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)]
pub struct PrometheusThanosResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<PrometheusThanosResourcesClaims>>,
    #[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)]
pub struct PrometheusThanosResourcesClaims {
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusThanosTracingConfig {
    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)]
pub struct PrometheusThanosVolumeMounts {
    #[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)]
pub struct PrometheusTolerations {
    #[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)]
pub struct PrometheusTopologySpreadConstraints {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
    pub label_selector: Option<metav1::LabelSelector>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchLabelKeys")]
    pub match_label_keys: Option<Vec<String>>,
    #[serde(rename = "maxSkew")]
    pub max_skew: i32,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "minDomains")]
    pub min_domains: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeAffinityPolicy")]
    pub node_affinity_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeTaintsPolicy")]
    pub node_taints_policy: Option<String>,
    #[serde(rename = "topologyKey")]
    pub topology_key: String,
    #[serde(rename = "whenUnsatisfiable")]
    pub when_unsatisfiable: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusTracingConfig {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clientType")]
    pub client_type: Option<PrometheusTracingConfigClientType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compression: Option<PrometheusTracingConfigCompression>,
    pub endpoint: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub insecure: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "samplingFraction")]
    pub sampling_fraction: Option<IntOrString>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
    pub tls_config: Option<PrometheusTracingConfigTlsConfig>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum PrometheusTracingConfigClientType {
    #[serde(rename = "http")]
    Http,
    #[serde(rename = "grpc")]
    Grpc,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum PrometheusTracingConfigCompression {
    #[serde(rename = "gzip")]
    Gzip,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusTracingConfigTlsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ca: Option<PrometheusTracingConfigTlsConfigCa>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
    pub ca_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<PrometheusTracingConfigTlsConfigCert>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
    pub cert_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
    pub insecure_skip_verify: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
    pub key_file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
    pub key_secret: Option<PrometheusTracingConfigTlsConfigKeySecret>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
    pub server_name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusTracingConfigTlsConfigCa {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusTracingConfigTlsConfigCaConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusTracingConfigTlsConfigCaSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusTracingConfigTlsConfigCaConfigMap {
    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)]
pub struct PrometheusTracingConfigTlsConfigCaSecret {
    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)]
pub struct PrometheusTracingConfigTlsConfigCert {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusTracingConfigTlsConfigCertConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusTracingConfigTlsConfigCertSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusTracingConfigTlsConfigCertConfigMap {
    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)]
pub struct PrometheusTracingConfigTlsConfigCertSecret {
    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)]
pub struct PrometheusTracingConfigTlsConfigKeySecret {
    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)]
pub struct PrometheusTsdb {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "outOfOrderTimeWindow")]
    pub out_of_order_time_window: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumeMounts {
    #[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)]
pub struct PrometheusVolumes {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "awsElasticBlockStore")]
    pub aws_elastic_block_store: Option<PrometheusVolumesAwsElasticBlockStore>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "azureDisk")]
    pub azure_disk: Option<PrometheusVolumesAzureDisk>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "azureFile")]
    pub azure_file: Option<PrometheusVolumesAzureFile>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cephfs: Option<PrometheusVolumesCephfs>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cinder: Option<PrometheusVolumesCinder>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusVolumesConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub csi: Option<PrometheusVolumesCsi>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "downwardAPI")]
    pub downward_api: Option<PrometheusVolumesDownwardApi>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "emptyDir")]
    pub empty_dir: Option<PrometheusVolumesEmptyDir>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ephemeral: Option<PrometheusVolumesEphemeral>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fc: Option<PrometheusVolumesFc>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "flexVolume")]
    pub flex_volume: Option<PrometheusVolumesFlexVolume>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub flocker: Option<PrometheusVolumesFlocker>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gcePersistentDisk")]
    pub gce_persistent_disk: Option<PrometheusVolumesGcePersistentDisk>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "gitRepo")]
    pub git_repo: Option<PrometheusVolumesGitRepo>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub glusterfs: Option<PrometheusVolumesGlusterfs>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostPath")]
    pub host_path: Option<PrometheusVolumesHostPath>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub iscsi: Option<PrometheusVolumesIscsi>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nfs: Option<PrometheusVolumesNfs>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "persistentVolumeClaim")]
    pub persistent_volume_claim: Option<PrometheusVolumesPersistentVolumeClaim>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "photonPersistentDisk")]
    pub photon_persistent_disk: Option<PrometheusVolumesPhotonPersistentDisk>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "portworxVolume")]
    pub portworx_volume: Option<PrometheusVolumesPortworxVolume>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub projected: Option<PrometheusVolumesProjected>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quobyte: Option<PrometheusVolumesQuobyte>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rbd: Option<PrometheusVolumesRbd>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "scaleIO")]
    pub scale_io: Option<PrometheusVolumesScaleIo>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusVolumesSecret>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storageos: Option<PrometheusVolumesStorageos>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "vsphereVolume")]
    pub vsphere_volume: Option<PrometheusVolumesVsphereVolume>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesAwsElasticBlockStore {
    #[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)]
pub struct PrometheusVolumesAzureDisk {
    #[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)]
pub struct PrometheusVolumesAzureFile {
    #[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)]
pub struct PrometheusVolumesCephfs {
    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<PrometheusVolumesCephfsSecretRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesCinder {
    #[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<PrometheusVolumesCinderSecretRef>,
    #[serde(rename = "volumeID")]
    pub volume_id: String,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesConfigMap {
    #[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<PrometheusVolumesConfigMapItems>>,
    #[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)]
pub struct PrometheusVolumesConfigMapItems {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesCsi {
    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<PrometheusVolumesCsiNodePublishSecretRef>,
    #[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)]
pub struct PrometheusVolumesCsiNodePublishSecretRef {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesDownwardApi {
    #[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<PrometheusVolumesDownwardApiItems>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesDownwardApiItems {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<PrometheusVolumesDownwardApiItemsFieldRef>,
    #[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<PrometheusVolumesDownwardApiItemsResourceFieldRef>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesDownwardApiItemsFieldRef {
    #[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)]
pub struct PrometheusVolumesDownwardApiItemsResourceFieldRef {
    #[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)]
pub struct PrometheusVolumesEmptyDir {
    #[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)]
pub struct PrometheusVolumesEphemeral {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeClaimTemplate")]
    pub volume_claim_template: Option<PrometheusVolumesEphemeralVolumeClaimTemplate>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesEphemeralVolumeClaimTemplate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<PrometheusVolumesEphemeralVolumeClaimTemplateMetadata>,
    pub spec: PrometheusVolumesEphemeralVolumeClaimTemplateSpec,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpec {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessModes")]
    pub access_modes: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSource")]
    pub data_source: Option<PrometheusVolumesEphemeralVolumeClaimTemplateSpecDataSource>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSourceRef")]
    pub data_source_ref: Option<PrometheusVolumesEphemeralVolumeClaimTemplateSpecDataSourceRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resources: Option<PrometheusVolumesEphemeralVolumeClaimTemplateSpecResources>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub selector: Option<metav1::LabelSelector>,
    #[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 = "volumeMode")]
    pub volume_mode: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
    pub volume_name: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpecDataSourceRef {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
    pub api_group: Option<String>,
    pub kind: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpecResources {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub claims: Option<Vec<PrometheusVolumesEphemeralVolumeClaimTemplateSpecResourcesClaims>>,
    #[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)]
pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpecResourcesClaims {
    pub name: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesFc {
    #[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)]
pub struct PrometheusVolumesFlexVolume {
    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<PrometheusVolumesFlexVolumeSecretRef>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesFlocker {
    #[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)]
pub struct PrometheusVolumesGcePersistentDisk {
    #[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)]
pub struct PrometheusVolumesGitRepo {
    #[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)]
pub struct PrometheusVolumesGlusterfs {
    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)]
pub struct PrometheusVolumesHostPath {
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
    pub r#type: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesIscsi {
    #[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<PrometheusVolumesIscsiSecretRef>,
    #[serde(rename = "targetPortal")]
    pub target_portal: String,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesNfs {
    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)]
pub struct PrometheusVolumesPersistentVolumeClaim {
    #[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)]
pub struct PrometheusVolumesPhotonPersistentDisk {
    #[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)]
pub struct PrometheusVolumesPortworxVolume {
    #[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)]
pub struct PrometheusVolumesProjected {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
    pub default_mode: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sources: Option<Vec<PrometheusVolumesProjectedSources>>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesProjectedSources {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusVolumesProjectedSourcesConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "downwardAPI")]
    pub downward_api: Option<PrometheusVolumesProjectedSourcesDownwardApi>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusVolumesProjectedSourcesSecret>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAccountToken")]
    pub service_account_token: Option<PrometheusVolumesProjectedSourcesServiceAccountToken>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesProjectedSourcesConfigMap {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<PrometheusVolumesProjectedSourcesConfigMapItems>>,
    #[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)]
pub struct PrometheusVolumesProjectedSourcesConfigMapItems {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesProjectedSourcesDownwardApiItems {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
    pub field_ref: Option<PrometheusVolumesProjectedSourcesDownwardApiItemsFieldRef>,
    #[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<PrometheusVolumesProjectedSourcesDownwardApiItemsResourceFieldRef>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesProjectedSourcesDownwardApiItemsFieldRef {
    #[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)]
pub struct PrometheusVolumesProjectedSourcesDownwardApiItemsResourceFieldRef {
    #[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)]
pub struct PrometheusVolumesProjectedSourcesSecret {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<PrometheusVolumesProjectedSourcesSecretItems>>,
    #[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)]
pub struct PrometheusVolumesProjectedSourcesSecretItems {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesProjectedSourcesServiceAccountToken {
    #[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)]
pub struct PrometheusVolumesQuobyte {
    #[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)]
pub struct PrometheusVolumesRbd {
    #[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<PrometheusVolumesRbdSecretRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
}

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

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesScaleIo {
    #[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: PrometheusVolumesScaleIoSecretRef,
    #[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)]
pub struct PrometheusVolumesScaleIoSecretRef {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesSecret {
    #[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<PrometheusVolumesSecretItems>>,
    #[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)]
pub struct PrometheusVolumesSecretItems {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<i32>,
    pub path: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesStorageos {
    #[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<PrometheusVolumesStorageosSecretRef>,
    #[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)]
pub struct PrometheusVolumesStorageosSecretRef {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusVolumesVsphereVolume {
    #[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)]
pub struct PrometheusWeb {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpConfig")]
    pub http_config: Option<PrometheusWebHttpConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxConnections")]
    pub max_connections: Option<i32>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "pageTitle")]
    pub page_title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
    pub tls_config: Option<PrometheusWebTlsConfig>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusWebHttpConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<PrometheusWebHttpConfigHeaders>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub http2: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusWebHttpConfigHeaders {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "contentSecurityPolicy")]
    pub content_security_policy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "strictTransportSecurity")]
    pub strict_transport_security: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "xContentTypeOptions")]
    pub x_content_type_options: Option<PrometheusWebHttpConfigHeadersXContentTypeOptions>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "xFrameOptions")]
    pub x_frame_options: Option<PrometheusWebHttpConfigHeadersXFrameOptions>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "xXSSProtection")]
    pub x_xss_protection: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum PrometheusWebHttpConfigHeadersXContentTypeOptions {
    #[serde(rename = "")]
    KopiumEmpty,
    NoSniff,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum PrometheusWebHttpConfigHeadersXFrameOptions {
    #[serde(rename = "")]
    KopiumEmpty,
    Deny,
    SameOrigin,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusWebTlsConfig {
    pub cert: PrometheusWebTlsConfigCert,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "cipherSuites")]
    pub cipher_suites: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "clientAuthType")]
    pub client_auth_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_ca: Option<PrometheusWebTlsConfigClientCa>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "curvePreferences")]
    pub curve_preferences: Option<Vec<String>>,
    #[serde(rename = "keySecret")]
    pub key_secret: PrometheusWebTlsConfigKeySecret,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxVersion")]
    pub max_version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "minVersion")]
    pub min_version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "preferServerCipherSuites")]
    pub prefer_server_cipher_suites: Option<bool>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusWebTlsConfigCert {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusWebTlsConfigCertConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusWebTlsConfigCertSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusWebTlsConfigCertConfigMap {
    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)]
pub struct PrometheusWebTlsConfigCertSecret {
    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)]
pub struct PrometheusWebTlsConfigClientCa {
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
    pub config_map: Option<PrometheusWebTlsConfigClientCaConfigMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<PrometheusWebTlsConfigClientCaSecret>,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusWebTlsConfigClientCaConfigMap {
    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)]
pub struct PrometheusWebTlsConfigClientCaSecret {
    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)]
pub struct PrometheusWebTlsConfigKeySecret {
    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)]
pub struct PrometheusStatus {
    #[serde(rename = "availableReplicas")]
    pub available_replicas: i32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conditions: Option<Vec<PrometheusStatusConditions>>,
    pub paused: bool,
    pub replicas: i32,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "shardStatuses")]
    pub shard_statuses: Option<Vec<PrometheusStatusShardStatuses>>,
    #[serde(rename = "unavailableReplicas")]
    pub unavailable_replicas: i32,
    #[serde(rename = "updatedReplicas")]
    pub updated_replicas: i32,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStatusConditions {
    #[serde(rename = "lastTransitionTime")]
    pub last_transition_time: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none", rename = "observedGeneration")]
    pub observed_generation: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    pub status: String,
    #[serde(rename = "type")]
    pub r#type: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct PrometheusStatusShardStatuses {
    #[serde(rename = "availableReplicas")]
    pub available_replicas: i32,
    pub replicas: i32,
    #[serde(rename = "shardID")]
    pub shard_id: String,
    #[serde(rename = "unavailableReplicas")]
    pub unavailable_replicas: i32,
    #[serde(rename = "updatedReplicas")]
    pub updated_replicas: i32,
}