1use kube::CustomResource;
11use serde::{Serialize, Deserialize};
12use std::collections::BTreeMap;
13use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
14use k8s_openapi::apimachinery::pkg::apis::meta::v1 as metav1;
15use schemars::JsonSchema;
16
17#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default)]
18#[kube(group = "monitoring.coreos.com", version = "v1", kind = "Prometheus", plural = "prometheuses")]
19#[kube(namespaced)]
20#[kube(status = "PrometheusStatus")]
21#[kube(schema = "disabled")]
22pub struct PrometheusSpec {
23 #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalAlertManagerConfigs")]
24 pub additional_alert_manager_configs: Option<PrometheusAdditionalAlertManagerConfigs>,
25 #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalAlertRelabelConfigs")]
26 pub additional_alert_relabel_configs: Option<PrometheusAdditionalAlertRelabelConfigs>,
27 #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalArgs")]
28 pub additional_args: Option<Vec<PrometheusAdditionalArgs>>,
29 #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalScrapeConfigs")]
30 pub additional_scrape_configs: Option<PrometheusAdditionalScrapeConfigs>,
31 #[serde(default, skip_serializing_if = "Option::is_none")]
32 pub affinity: Option<PrometheusAffinity>,
33 #[serde(default, skip_serializing_if = "Option::is_none")]
34 pub alerting: Option<PrometheusAlerting>,
35 #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowOverlappingBlocks")]
36 pub allow_overlapping_blocks: Option<bool>,
37 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiserverConfig")]
38 pub apiserver_config: Option<PrometheusApiserverConfig>,
39 #[serde(default, skip_serializing_if = "Option::is_none", rename = "arbitraryFSAccessThroughSMs")]
40 pub arbitrary_fs_access_through_s_ms: Option<PrometheusArbitraryFsAccessThroughSMs>,
41 #[serde(default, skip_serializing_if = "Option::is_none", rename = "baseImage")]
42 pub base_image: Option<String>,
43 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMaps")]
44 pub config_maps: Option<Vec<String>>,
45 #[serde(default, skip_serializing_if = "Option::is_none")]
46 pub containers: Option<Vec<PrometheusContainers>>,
47 #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableCompaction")]
48 pub disable_compaction: Option<bool>,
49 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enableAdminAPI")]
50 pub enable_admin_api: Option<bool>,
51 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enableFeatures")]
52 pub enable_features: Option<Vec<String>>,
53 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enableRemoteWriteReceiver")]
54 pub enable_remote_write_receiver: Option<bool>,
55 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedBodySizeLimit")]
56 pub enforced_body_size_limit: Option<String>,
57 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedLabelLimit")]
58 pub enforced_label_limit: Option<i64>,
59 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedLabelNameLengthLimit")]
60 pub enforced_label_name_length_limit: Option<i64>,
61 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedLabelValueLengthLimit")]
62 pub enforced_label_value_length_limit: Option<i64>,
63 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedNamespaceLabel")]
64 pub enforced_namespace_label: Option<String>,
65 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedSampleLimit")]
66 pub enforced_sample_limit: Option<i64>,
67 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enforcedTargetLimit")]
68 pub enforced_target_limit: Option<i64>,
69 #[serde(default, skip_serializing_if = "Option::is_none", rename = "evaluationInterval")]
70 pub evaluation_interval: Option<String>,
71 #[serde(default, skip_serializing_if = "Option::is_none", rename = "excludedFromEnforcement")]
72 pub excluded_from_enforcement: Option<Vec<PrometheusExcludedFromEnforcement>>,
73 #[serde(default, skip_serializing_if = "Option::is_none")]
74 pub exemplars: Option<PrometheusExemplars>,
75 #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalLabels")]
76 pub external_labels: Option<BTreeMap<String, String>>,
77 #[serde(default, skip_serializing_if = "Option::is_none", rename = "externalUrl")]
78 pub external_url: Option<String>,
79 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostAliases")]
80 pub host_aliases: Option<Vec<PrometheusHostAliases>>,
81 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostNetwork")]
82 pub host_network: Option<bool>,
83 #[serde(default, skip_serializing_if = "Option::is_none", rename = "ignoreNamespaceSelectors")]
84 pub ignore_namespace_selectors: Option<bool>,
85 #[serde(default, skip_serializing_if = "Option::is_none")]
86 pub image: Option<String>,
87 #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
88 pub image_pull_policy: Option<PrometheusImagePullPolicy>,
89 #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullSecrets")]
90 pub image_pull_secrets: Option<Vec<PrometheusImagePullSecrets>>,
91 #[serde(default, skip_serializing_if = "Option::is_none", rename = "initContainers")]
92 pub init_containers: Option<Vec<PrometheusInitContainers>>,
93 #[serde(default, skip_serializing_if = "Option::is_none", rename = "listenLocal")]
94 pub listen_local: Option<bool>,
95 #[serde(default, skip_serializing_if = "Option::is_none", rename = "logFormat")]
96 pub log_format: Option<PrometheusLogFormat>,
97 #[serde(default, skip_serializing_if = "Option::is_none", rename = "logLevel")]
98 pub log_level: Option<PrometheusLogLevel>,
99 #[serde(default, skip_serializing_if = "Option::is_none", rename = "minReadySeconds")]
100 pub min_ready_seconds: Option<i32>,
101 #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeSelector")]
102 pub node_selector: Option<BTreeMap<String, String>>,
103 #[serde(default, skip_serializing_if = "Option::is_none", rename = "overrideHonorLabels")]
104 pub override_honor_labels: Option<bool>,
105 #[serde(default, skip_serializing_if = "Option::is_none", rename = "overrideHonorTimestamps")]
106 pub override_honor_timestamps: Option<bool>,
107 #[serde(default, skip_serializing_if = "Option::is_none")]
108 pub paused: Option<bool>,
109 #[serde(default, skip_serializing_if = "Option::is_none", rename = "podMetadata")]
110 pub pod_metadata: Option<PrometheusPodMetadata>,
111 #[serde(default, skip_serializing_if = "Option::is_none", rename = "podMonitorNamespaceSelector")]
112 pub pod_monitor_namespace_selector: Option<metav1::LabelSelector>,
113 #[serde(default, skip_serializing_if = "Option::is_none", rename = "podMonitorSelector")]
114 pub pod_monitor_selector: Option<metav1::LabelSelector>,
115 #[serde(default, skip_serializing_if = "Option::is_none", rename = "podTargetLabels")]
116 pub pod_target_labels: Option<Vec<String>>,
117 #[serde(default, skip_serializing_if = "Option::is_none", rename = "portName")]
118 pub port_name: Option<String>,
119 #[serde(default, skip_serializing_if = "Option::is_none", rename = "priorityClassName")]
120 pub priority_class_name: Option<String>,
121 #[serde(default, skip_serializing_if = "Option::is_none", rename = "probeNamespaceSelector")]
122 pub probe_namespace_selector: Option<metav1::LabelSelector>,
123 #[serde(default, skip_serializing_if = "Option::is_none", rename = "probeSelector")]
124 pub probe_selector: Option<metav1::LabelSelector>,
125 #[serde(default, skip_serializing_if = "Option::is_none", rename = "prometheusExternalLabelName")]
126 pub prometheus_external_label_name: Option<String>,
127 #[serde(default, skip_serializing_if = "Option::is_none", rename = "prometheusRulesExcludedFromEnforce")]
128 pub prometheus_rules_excluded_from_enforce: Option<Vec<PrometheusPrometheusRulesExcludedFromEnforce>>,
129 #[serde(default, skip_serializing_if = "Option::is_none")]
130 pub query: Option<PrometheusQuery>,
131 #[serde(default, skip_serializing_if = "Option::is_none", rename = "queryLogFile")]
132 pub query_log_file: Option<String>,
133 #[serde(default, skip_serializing_if = "Option::is_none", rename = "remoteRead")]
134 pub remote_read: Option<Vec<PrometheusRemoteRead>>,
135 #[serde(default, skip_serializing_if = "Option::is_none", rename = "remoteWrite")]
136 pub remote_write: Option<Vec<PrometheusRemoteWrite>>,
137 #[serde(default, skip_serializing_if = "Option::is_none", rename = "replicaExternalLabelName")]
138 pub replica_external_label_name: Option<String>,
139 #[serde(default, skip_serializing_if = "Option::is_none")]
140 pub replicas: Option<i32>,
141 #[serde(default, skip_serializing_if = "Option::is_none")]
142 pub resources: Option<PrometheusResources>,
143 #[serde(default, skip_serializing_if = "Option::is_none")]
144 pub retention: Option<String>,
145 #[serde(default, skip_serializing_if = "Option::is_none", rename = "retentionSize")]
146 pub retention_size: Option<String>,
147 #[serde(default, skip_serializing_if = "Option::is_none", rename = "routePrefix")]
148 pub route_prefix: Option<String>,
149 #[serde(default, skip_serializing_if = "Option::is_none", rename = "ruleNamespaceSelector")]
150 pub rule_namespace_selector: Option<metav1::LabelSelector>,
151 #[serde(default, skip_serializing_if = "Option::is_none", rename = "ruleSelector")]
152 pub rule_selector: Option<metav1::LabelSelector>,
153 #[serde(default, skip_serializing_if = "Option::is_none")]
154 pub rules: Option<PrometheusRules>,
155 #[serde(default, skip_serializing_if = "Option::is_none", rename = "scrapeConfigNamespaceSelector")]
156 pub scrape_config_namespace_selector: Option<metav1::LabelSelector>,
157 #[serde(default, skip_serializing_if = "Option::is_none", rename = "scrapeConfigSelector")]
158 pub scrape_config_selector: Option<metav1::LabelSelector>,
159 #[serde(default, skip_serializing_if = "Option::is_none", rename = "scrapeInterval")]
160 pub scrape_interval: Option<String>,
161 #[serde(default, skip_serializing_if = "Option::is_none", rename = "scrapeTimeout")]
162 pub scrape_timeout: Option<String>,
163 #[serde(default, skip_serializing_if = "Option::is_none")]
164 pub secrets: Option<Vec<String>>,
165 #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
166 pub security_context: Option<PrometheusSecurityContext>,
167 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAccountName")]
168 pub service_account_name: Option<String>,
169 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceMonitorNamespaceSelector")]
170 pub service_monitor_namespace_selector: Option<metav1::LabelSelector>,
171 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceMonitorSelector")]
172 pub service_monitor_selector: Option<metav1::LabelSelector>,
173 #[serde(default, skip_serializing_if = "Option::is_none")]
174 pub sha: Option<String>,
175 #[serde(default, skip_serializing_if = "Option::is_none")]
176 pub shards: Option<i32>,
177 #[serde(default, skip_serializing_if = "Option::is_none")]
178 pub storage: Option<PrometheusStorage>,
179 #[serde(default, skip_serializing_if = "Option::is_none")]
180 pub tag: Option<String>,
181 #[serde(default, skip_serializing_if = "Option::is_none")]
182 pub thanos: Option<PrometheusThanos>,
183 #[serde(default, skip_serializing_if = "Option::is_none")]
184 pub tolerations: Option<Vec<PrometheusTolerations>>,
185 #[serde(default, skip_serializing_if = "Option::is_none", rename = "topologySpreadConstraints")]
186 pub topology_spread_constraints: Option<Vec<PrometheusTopologySpreadConstraints>>,
187 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tracingConfig")]
188 pub tracing_config: Option<PrometheusTracingConfig>,
189 #[serde(default, skip_serializing_if = "Option::is_none")]
190 pub tsdb: Option<PrometheusTsdb>,
191 #[serde(default, skip_serializing_if = "Option::is_none")]
192 pub version: Option<String>,
193 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
194 pub volume_mounts: Option<Vec<PrometheusVolumeMounts>>,
195 #[serde(default, skip_serializing_if = "Option::is_none")]
196 pub volumes: Option<Vec<PrometheusVolumes>>,
197 #[serde(default, skip_serializing_if = "Option::is_none", rename = "walCompression")]
198 pub wal_compression: Option<bool>,
199 #[serde(default, skip_serializing_if = "Option::is_none")]
200 pub web: Option<PrometheusWeb>,
201}
202
203#[derive(Serialize, Deserialize, Clone, Debug, Default)]
204pub struct PrometheusAdditionalAlertManagerConfigs {
205 pub key: String,
206 #[serde(default, skip_serializing_if = "Option::is_none")]
207 pub name: Option<String>,
208 #[serde(default, skip_serializing_if = "Option::is_none")]
209 pub optional: Option<bool>,
210}
211
212#[derive(Serialize, Deserialize, Clone, Debug, Default)]
213pub struct PrometheusAdditionalAlertRelabelConfigs {
214 pub key: String,
215 #[serde(default, skip_serializing_if = "Option::is_none")]
216 pub name: Option<String>,
217 #[serde(default, skip_serializing_if = "Option::is_none")]
218 pub optional: Option<bool>,
219}
220
221#[derive(Serialize, Deserialize, Clone, Debug, Default)]
222pub struct PrometheusAdditionalArgs {
223 pub name: String,
224 #[serde(default, skip_serializing_if = "Option::is_none")]
225 pub value: Option<String>,
226}
227
228#[derive(Serialize, Deserialize, Clone, Debug, Default)]
229pub struct PrometheusAdditionalScrapeConfigs {
230 pub key: String,
231 #[serde(default, skip_serializing_if = "Option::is_none")]
232 pub name: Option<String>,
233 #[serde(default, skip_serializing_if = "Option::is_none")]
234 pub optional: Option<bool>,
235}
236
237#[derive(Serialize, Deserialize, Clone, Debug, Default)]
238pub struct PrometheusAffinity {
239 #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeAffinity")]
240 pub node_affinity: Option<PrometheusAffinityNodeAffinity>,
241 #[serde(default, skip_serializing_if = "Option::is_none", rename = "podAffinity")]
242 pub pod_affinity: Option<PrometheusAffinityPodAffinity>,
243 #[serde(default, skip_serializing_if = "Option::is_none", rename = "podAntiAffinity")]
244 pub pod_anti_affinity: Option<PrometheusAffinityPodAntiAffinity>,
245}
246
247#[derive(Serialize, Deserialize, Clone, Debug, Default)]
248pub struct PrometheusAffinityNodeAffinity {
249 #[serde(default, skip_serializing_if = "Option::is_none", rename = "preferredDuringSchedulingIgnoredDuringExecution")]
250 pub preferred_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution>>,
251 #[serde(default, skip_serializing_if = "Option::is_none", rename = "requiredDuringSchedulingIgnoredDuringExecution")]
252 pub required_during_scheduling_ignored_during_execution: Option<PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution>,
253}
254
255#[derive(Serialize, Deserialize, Clone, Debug, Default)]
256pub struct PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution {
257 pub preference: PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference,
258 pub weight: i32,
259}
260
261#[derive(Serialize, Deserialize, Clone, Debug, Default)]
262pub struct PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference {
263 #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchExpressions")]
264 pub match_expressions: Option<Vec<PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions>>,
265 #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchFields")]
266 pub match_fields: Option<Vec<PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields>>,
267}
268
269#[derive(Serialize, Deserialize, Clone, Debug, Default)]
270pub struct PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions {
271 pub key: String,
272 pub operator: String,
273 #[serde(default, skip_serializing_if = "Option::is_none")]
274 pub values: Option<Vec<String>>,
275}
276
277#[derive(Serialize, Deserialize, Clone, Debug, Default)]
278pub struct PrometheusAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields {
279 pub key: String,
280 pub operator: String,
281 #[serde(default, skip_serializing_if = "Option::is_none")]
282 pub values: Option<Vec<String>>,
283}
284
285#[derive(Serialize, Deserialize, Clone, Debug, Default)]
286pub struct PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution {
287 #[serde(rename = "nodeSelectorTerms")]
288 pub node_selector_terms: Vec<PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms>,
289}
290
291#[derive(Serialize, Deserialize, Clone, Debug, Default)]
292pub struct PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms {
293 #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchExpressions")]
294 pub match_expressions: Option<Vec<PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions>>,
295 #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchFields")]
296 pub match_fields: Option<Vec<PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields>>,
297}
298
299#[derive(Serialize, Deserialize, Clone, Debug, Default)]
300pub struct PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions {
301 pub key: String,
302 pub operator: String,
303 #[serde(default, skip_serializing_if = "Option::is_none")]
304 pub values: Option<Vec<String>>,
305}
306
307#[derive(Serialize, Deserialize, Clone, Debug, Default)]
308pub struct PrometheusAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields {
309 pub key: String,
310 pub operator: String,
311 #[serde(default, skip_serializing_if = "Option::is_none")]
312 pub values: Option<Vec<String>>,
313}
314
315#[derive(Serialize, Deserialize, Clone, Debug, Default)]
316pub struct PrometheusAffinityPodAffinity {
317 #[serde(default, skip_serializing_if = "Option::is_none", rename = "preferredDuringSchedulingIgnoredDuringExecution")]
318 pub preferred_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution>>,
319 #[serde(default, skip_serializing_if = "Option::is_none", rename = "requiredDuringSchedulingIgnoredDuringExecution")]
320 pub required_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution>>,
321}
322
323#[derive(Serialize, Deserialize, Clone, Debug, Default)]
324pub struct PrometheusAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution {
325 #[serde(rename = "podAffinityTerm")]
326 pub pod_affinity_term: PrometheusAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm,
327 pub weight: i32,
328}
329
330#[derive(Serialize, Deserialize, Clone, Debug, Default)]
331pub struct PrometheusAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
332 #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
333 pub label_selector: Option<metav1::LabelSelector>,
334 #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
335 pub namespace_selector: Option<metav1::LabelSelector>,
336 #[serde(default, skip_serializing_if = "Option::is_none")]
337 pub namespaces: Option<Vec<String>>,
338 #[serde(rename = "topologyKey")]
339 pub topology_key: String,
340}
341
342#[derive(Serialize, Deserialize, Clone, Debug, Default)]
343pub struct PrometheusAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution {
344 #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
345 pub label_selector: Option<metav1::LabelSelector>,
346 #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
347 pub namespace_selector: Option<metav1::LabelSelector>,
348 #[serde(default, skip_serializing_if = "Option::is_none")]
349 pub namespaces: Option<Vec<String>>,
350 #[serde(rename = "topologyKey")]
351 pub topology_key: String,
352}
353
354#[derive(Serialize, Deserialize, Clone, Debug, Default)]
355pub struct PrometheusAffinityPodAntiAffinity {
356 #[serde(default, skip_serializing_if = "Option::is_none", rename = "preferredDuringSchedulingIgnoredDuringExecution")]
357 pub preferred_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution>>,
358 #[serde(default, skip_serializing_if = "Option::is_none", rename = "requiredDuringSchedulingIgnoredDuringExecution")]
359 pub required_during_scheduling_ignored_during_execution: Option<Vec<PrometheusAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution>>,
360}
361
362#[derive(Serialize, Deserialize, Clone, Debug, Default)]
363pub struct PrometheusAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution {
364 #[serde(rename = "podAffinityTerm")]
365 pub pod_affinity_term: PrometheusAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm,
366 pub weight: i32,
367}
368
369#[derive(Serialize, Deserialize, Clone, Debug, Default)]
370pub struct PrometheusAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
371 #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
372 pub label_selector: Option<metav1::LabelSelector>,
373 #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
374 pub namespace_selector: Option<metav1::LabelSelector>,
375 #[serde(default, skip_serializing_if = "Option::is_none")]
376 pub namespaces: Option<Vec<String>>,
377 #[serde(rename = "topologyKey")]
378 pub topology_key: String,
379}
380
381#[derive(Serialize, Deserialize, Clone, Debug, Default)]
382pub struct PrometheusAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution {
383 #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
384 pub label_selector: Option<metav1::LabelSelector>,
385 #[serde(default, skip_serializing_if = "Option::is_none", rename = "namespaceSelector")]
386 pub namespace_selector: Option<metav1::LabelSelector>,
387 #[serde(default, skip_serializing_if = "Option::is_none")]
388 pub namespaces: Option<Vec<String>>,
389 #[serde(rename = "topologyKey")]
390 pub topology_key: String,
391}
392
393#[derive(Serialize, Deserialize, Clone, Debug, Default)]
394pub struct PrometheusAlerting {
395 pub alertmanagers: Vec<PrometheusAlertingAlertmanagers>,
396}
397
398#[derive(Serialize, Deserialize, Clone, Debug, Default)]
399pub struct PrometheusAlertingAlertmanagers {
400 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
401 pub api_version: Option<String>,
402 #[serde(default, skip_serializing_if = "Option::is_none")]
403 pub authorization: Option<PrometheusAlertingAlertmanagersAuthorization>,
404 #[serde(default, skip_serializing_if = "Option::is_none", rename = "basicAuth")]
405 pub basic_auth: Option<PrometheusAlertingAlertmanagersBasicAuth>,
406 #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerTokenFile")]
407 pub bearer_token_file: Option<String>,
408 #[serde(default, skip_serializing_if = "Option::is_none", rename = "enableHttp2")]
409 pub enable_http2: Option<bool>,
410 pub name: String,
411 pub namespace: String,
412 #[serde(default, skip_serializing_if = "Option::is_none", rename = "pathPrefix")]
413 pub path_prefix: Option<String>,
414 pub port: IntOrString,
415 #[serde(default, skip_serializing_if = "Option::is_none")]
416 pub scheme: Option<String>,
417 #[serde(default, skip_serializing_if = "Option::is_none")]
418 pub timeout: Option<String>,
419 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
420 pub tls_config: Option<PrometheusAlertingAlertmanagersTlsConfig>,
421}
422
423#[derive(Serialize, Deserialize, Clone, Debug, Default)]
424pub struct PrometheusAlertingAlertmanagersAuthorization {
425 #[serde(default, skip_serializing_if = "Option::is_none")]
426 pub credentials: Option<PrometheusAlertingAlertmanagersAuthorizationCredentials>,
427 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
428 pub r#type: Option<String>,
429}
430
431#[derive(Serialize, Deserialize, Clone, Debug, Default)]
432pub struct PrometheusAlertingAlertmanagersAuthorizationCredentials {
433 pub key: String,
434 #[serde(default, skip_serializing_if = "Option::is_none")]
435 pub name: Option<String>,
436 #[serde(default, skip_serializing_if = "Option::is_none")]
437 pub optional: Option<bool>,
438}
439
440#[derive(Serialize, Deserialize, Clone, Debug, Default)]
441pub struct PrometheusAlertingAlertmanagersBasicAuth {
442 #[serde(default, skip_serializing_if = "Option::is_none")]
443 pub password: Option<PrometheusAlertingAlertmanagersBasicAuthPassword>,
444 #[serde(default, skip_serializing_if = "Option::is_none")]
445 pub username: Option<PrometheusAlertingAlertmanagersBasicAuthUsername>,
446}
447
448#[derive(Serialize, Deserialize, Clone, Debug, Default)]
449pub struct PrometheusAlertingAlertmanagersBasicAuthPassword {
450 pub key: String,
451 #[serde(default, skip_serializing_if = "Option::is_none")]
452 pub name: Option<String>,
453 #[serde(default, skip_serializing_if = "Option::is_none")]
454 pub optional: Option<bool>,
455}
456
457#[derive(Serialize, Deserialize, Clone, Debug, Default)]
458pub struct PrometheusAlertingAlertmanagersBasicAuthUsername {
459 pub key: String,
460 #[serde(default, skip_serializing_if = "Option::is_none")]
461 pub name: Option<String>,
462 #[serde(default, skip_serializing_if = "Option::is_none")]
463 pub optional: Option<bool>,
464}
465
466#[derive(Serialize, Deserialize, Clone, Debug, Default)]
467pub struct PrometheusAlertingAlertmanagersTlsConfig {
468 #[serde(default, skip_serializing_if = "Option::is_none")]
469 pub ca: Option<PrometheusAlertingAlertmanagersTlsConfigCa>,
470 #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
471 pub ca_file: Option<String>,
472 #[serde(default, skip_serializing_if = "Option::is_none")]
473 pub cert: Option<PrometheusAlertingAlertmanagersTlsConfigCert>,
474 #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
475 pub cert_file: Option<String>,
476 #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
477 pub insecure_skip_verify: Option<bool>,
478 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
479 pub key_file: Option<String>,
480 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
481 pub key_secret: Option<PrometheusAlertingAlertmanagersTlsConfigKeySecret>,
482 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
483 pub server_name: Option<String>,
484}
485
486#[derive(Serialize, Deserialize, Clone, Debug, Default)]
487pub struct PrometheusAlertingAlertmanagersTlsConfigCa {
488 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
489 pub config_map: Option<PrometheusAlertingAlertmanagersTlsConfigCaConfigMap>,
490 #[serde(default, skip_serializing_if = "Option::is_none")]
491 pub secret: Option<PrometheusAlertingAlertmanagersTlsConfigCaSecret>,
492}
493
494#[derive(Serialize, Deserialize, Clone, Debug, Default)]
495pub struct PrometheusAlertingAlertmanagersTlsConfigCaConfigMap {
496 pub key: String,
497 #[serde(default, skip_serializing_if = "Option::is_none")]
498 pub name: Option<String>,
499 #[serde(default, skip_serializing_if = "Option::is_none")]
500 pub optional: Option<bool>,
501}
502
503#[derive(Serialize, Deserialize, Clone, Debug, Default)]
504pub struct PrometheusAlertingAlertmanagersTlsConfigCaSecret {
505 pub key: String,
506 #[serde(default, skip_serializing_if = "Option::is_none")]
507 pub name: Option<String>,
508 #[serde(default, skip_serializing_if = "Option::is_none")]
509 pub optional: Option<bool>,
510}
511
512#[derive(Serialize, Deserialize, Clone, Debug, Default)]
513pub struct PrometheusAlertingAlertmanagersTlsConfigCert {
514 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
515 pub config_map: Option<PrometheusAlertingAlertmanagersTlsConfigCertConfigMap>,
516 #[serde(default, skip_serializing_if = "Option::is_none")]
517 pub secret: Option<PrometheusAlertingAlertmanagersTlsConfigCertSecret>,
518}
519
520#[derive(Serialize, Deserialize, Clone, Debug, Default)]
521pub struct PrometheusAlertingAlertmanagersTlsConfigCertConfigMap {
522 pub key: String,
523 #[serde(default, skip_serializing_if = "Option::is_none")]
524 pub name: Option<String>,
525 #[serde(default, skip_serializing_if = "Option::is_none")]
526 pub optional: Option<bool>,
527}
528
529#[derive(Serialize, Deserialize, Clone, Debug, Default)]
530pub struct PrometheusAlertingAlertmanagersTlsConfigCertSecret {
531 pub key: String,
532 #[serde(default, skip_serializing_if = "Option::is_none")]
533 pub name: Option<String>,
534 #[serde(default, skip_serializing_if = "Option::is_none")]
535 pub optional: Option<bool>,
536}
537
538#[derive(Serialize, Deserialize, Clone, Debug, Default)]
539pub struct PrometheusAlertingAlertmanagersTlsConfigKeySecret {
540 pub key: String,
541 #[serde(default, skip_serializing_if = "Option::is_none")]
542 pub name: Option<String>,
543 #[serde(default, skip_serializing_if = "Option::is_none")]
544 pub optional: Option<bool>,
545}
546
547#[derive(Serialize, Deserialize, Clone, Debug, Default)]
548pub struct PrometheusApiserverConfig {
549 #[serde(default, skip_serializing_if = "Option::is_none")]
550 pub authorization: Option<PrometheusApiserverConfigAuthorization>,
551 #[serde(default, skip_serializing_if = "Option::is_none", rename = "basicAuth")]
552 pub basic_auth: Option<PrometheusApiserverConfigBasicAuth>,
553 #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerToken")]
554 pub bearer_token: Option<String>,
555 #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerTokenFile")]
556 pub bearer_token_file: Option<String>,
557 pub host: String,
558 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
559 pub tls_config: Option<PrometheusApiserverConfigTlsConfig>,
560}
561
562#[derive(Serialize, Deserialize, Clone, Debug, Default)]
563pub struct PrometheusApiserverConfigAuthorization {
564 #[serde(default, skip_serializing_if = "Option::is_none")]
565 pub credentials: Option<PrometheusApiserverConfigAuthorizationCredentials>,
566 #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsFile")]
567 pub credentials_file: Option<String>,
568 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
569 pub r#type: Option<String>,
570}
571
572#[derive(Serialize, Deserialize, Clone, Debug, Default)]
573pub struct PrometheusApiserverConfigAuthorizationCredentials {
574 pub key: String,
575 #[serde(default, skip_serializing_if = "Option::is_none")]
576 pub name: Option<String>,
577 #[serde(default, skip_serializing_if = "Option::is_none")]
578 pub optional: Option<bool>,
579}
580
581#[derive(Serialize, Deserialize, Clone, Debug, Default)]
582pub struct PrometheusApiserverConfigBasicAuth {
583 #[serde(default, skip_serializing_if = "Option::is_none")]
584 pub password: Option<PrometheusApiserverConfigBasicAuthPassword>,
585 #[serde(default, skip_serializing_if = "Option::is_none")]
586 pub username: Option<PrometheusApiserverConfigBasicAuthUsername>,
587}
588
589#[derive(Serialize, Deserialize, Clone, Debug, Default)]
590pub struct PrometheusApiserverConfigBasicAuthPassword {
591 pub key: String,
592 #[serde(default, skip_serializing_if = "Option::is_none")]
593 pub name: Option<String>,
594 #[serde(default, skip_serializing_if = "Option::is_none")]
595 pub optional: Option<bool>,
596}
597
598#[derive(Serialize, Deserialize, Clone, Debug, Default)]
599pub struct PrometheusApiserverConfigBasicAuthUsername {
600 pub key: String,
601 #[serde(default, skip_serializing_if = "Option::is_none")]
602 pub name: Option<String>,
603 #[serde(default, skip_serializing_if = "Option::is_none")]
604 pub optional: Option<bool>,
605}
606
607#[derive(Serialize, Deserialize, Clone, Debug, Default)]
608pub struct PrometheusApiserverConfigTlsConfig {
609 #[serde(default, skip_serializing_if = "Option::is_none")]
610 pub ca: Option<PrometheusApiserverConfigTlsConfigCa>,
611 #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
612 pub ca_file: Option<String>,
613 #[serde(default, skip_serializing_if = "Option::is_none")]
614 pub cert: Option<PrometheusApiserverConfigTlsConfigCert>,
615 #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
616 pub cert_file: Option<String>,
617 #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
618 pub insecure_skip_verify: Option<bool>,
619 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
620 pub key_file: Option<String>,
621 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
622 pub key_secret: Option<PrometheusApiserverConfigTlsConfigKeySecret>,
623 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
624 pub server_name: Option<String>,
625}
626
627#[derive(Serialize, Deserialize, Clone, Debug, Default)]
628pub struct PrometheusApiserverConfigTlsConfigCa {
629 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
630 pub config_map: Option<PrometheusApiserverConfigTlsConfigCaConfigMap>,
631 #[serde(default, skip_serializing_if = "Option::is_none")]
632 pub secret: Option<PrometheusApiserverConfigTlsConfigCaSecret>,
633}
634
635#[derive(Serialize, Deserialize, Clone, Debug, Default)]
636pub struct PrometheusApiserverConfigTlsConfigCaConfigMap {
637 pub key: String,
638 #[serde(default, skip_serializing_if = "Option::is_none")]
639 pub name: Option<String>,
640 #[serde(default, skip_serializing_if = "Option::is_none")]
641 pub optional: Option<bool>,
642}
643
644#[derive(Serialize, Deserialize, Clone, Debug, Default)]
645pub struct PrometheusApiserverConfigTlsConfigCaSecret {
646 pub key: String,
647 #[serde(default, skip_serializing_if = "Option::is_none")]
648 pub name: Option<String>,
649 #[serde(default, skip_serializing_if = "Option::is_none")]
650 pub optional: Option<bool>,
651}
652
653#[derive(Serialize, Deserialize, Clone, Debug, Default)]
654pub struct PrometheusApiserverConfigTlsConfigCert {
655 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
656 pub config_map: Option<PrometheusApiserverConfigTlsConfigCertConfigMap>,
657 #[serde(default, skip_serializing_if = "Option::is_none")]
658 pub secret: Option<PrometheusApiserverConfigTlsConfigCertSecret>,
659}
660
661#[derive(Serialize, Deserialize, Clone, Debug, Default)]
662pub struct PrometheusApiserverConfigTlsConfigCertConfigMap {
663 pub key: String,
664 #[serde(default, skip_serializing_if = "Option::is_none")]
665 pub name: Option<String>,
666 #[serde(default, skip_serializing_if = "Option::is_none")]
667 pub optional: Option<bool>,
668}
669
670#[derive(Serialize, Deserialize, Clone, Debug, Default)]
671pub struct PrometheusApiserverConfigTlsConfigCertSecret {
672 pub key: String,
673 #[serde(default, skip_serializing_if = "Option::is_none")]
674 pub name: Option<String>,
675 #[serde(default, skip_serializing_if = "Option::is_none")]
676 pub optional: Option<bool>,
677}
678
679#[derive(Serialize, Deserialize, Clone, Debug, Default)]
680pub struct PrometheusApiserverConfigTlsConfigKeySecret {
681 pub key: String,
682 #[serde(default, skip_serializing_if = "Option::is_none")]
683 pub name: Option<String>,
684 #[serde(default, skip_serializing_if = "Option::is_none")]
685 pub optional: Option<bool>,
686}
687
688#[derive(Serialize, Deserialize, Clone, Debug, Default)]
689pub struct PrometheusArbitraryFsAccessThroughSMs {
690 #[serde(default, skip_serializing_if = "Option::is_none")]
691 pub deny: Option<bool>,
692}
693
694#[derive(Serialize, Deserialize, Clone, Debug, Default)]
695pub struct PrometheusContainers {
696 #[serde(default, skip_serializing_if = "Option::is_none")]
697 pub args: Option<Vec<String>>,
698 #[serde(default, skip_serializing_if = "Option::is_none")]
699 pub command: Option<Vec<String>>,
700 #[serde(default, skip_serializing_if = "Option::is_none")]
701 pub env: Option<Vec<PrometheusContainersEnv>>,
702 #[serde(default, skip_serializing_if = "Option::is_none", rename = "envFrom")]
703 pub env_from: Option<Vec<PrometheusContainersEnvFrom>>,
704 #[serde(default, skip_serializing_if = "Option::is_none")]
705 pub image: Option<String>,
706 #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
707 pub image_pull_policy: Option<String>,
708 #[serde(default, skip_serializing_if = "Option::is_none")]
709 pub lifecycle: Option<PrometheusContainersLifecycle>,
710 #[serde(default, skip_serializing_if = "Option::is_none", rename = "livenessProbe")]
711 pub liveness_probe: Option<PrometheusContainersLivenessProbe>,
712 pub name: String,
713 #[serde(default, skip_serializing_if = "Option::is_none")]
714 pub ports: Option<Vec<PrometheusContainersPorts>>,
715 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readinessProbe")]
716 pub readiness_probe: Option<PrometheusContainersReadinessProbe>,
717 #[serde(default, skip_serializing_if = "Option::is_none", rename = "resizePolicy")]
718 pub resize_policy: Option<Vec<PrometheusContainersResizePolicy>>,
719 #[serde(default, skip_serializing_if = "Option::is_none")]
720 pub resources: Option<PrometheusContainersResources>,
721 #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
722 pub security_context: Option<PrometheusContainersSecurityContext>,
723 #[serde(default, skip_serializing_if = "Option::is_none", rename = "startupProbe")]
724 pub startup_probe: Option<PrometheusContainersStartupProbe>,
725 #[serde(default, skip_serializing_if = "Option::is_none")]
726 pub stdin: Option<bool>,
727 #[serde(default, skip_serializing_if = "Option::is_none", rename = "stdinOnce")]
728 pub stdin_once: Option<bool>,
729 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationMessagePath")]
730 pub termination_message_path: Option<String>,
731 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationMessagePolicy")]
732 pub termination_message_policy: Option<String>,
733 #[serde(default, skip_serializing_if = "Option::is_none")]
734 pub tty: Option<bool>,
735 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeDevices")]
736 pub volume_devices: Option<Vec<PrometheusContainersVolumeDevices>>,
737 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
738 pub volume_mounts: Option<Vec<PrometheusContainersVolumeMounts>>,
739 #[serde(default, skip_serializing_if = "Option::is_none", rename = "workingDir")]
740 pub working_dir: Option<String>,
741}
742
743#[derive(Serialize, Deserialize, Clone, Debug, Default)]
744pub struct PrometheusContainersEnv {
745 pub name: String,
746 #[serde(default, skip_serializing_if = "Option::is_none")]
747 pub value: Option<String>,
748 #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
749 pub value_from: Option<PrometheusContainersEnvValueFrom>,
750}
751
752#[derive(Serialize, Deserialize, Clone, Debug, Default)]
753pub struct PrometheusContainersEnvValueFrom {
754 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
755 pub config_map_key_ref: Option<PrometheusContainersEnvValueFromConfigMapKeyRef>,
756 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
757 pub field_ref: Option<PrometheusContainersEnvValueFromFieldRef>,
758 #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
759 pub resource_field_ref: Option<PrometheusContainersEnvValueFromResourceFieldRef>,
760 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
761 pub secret_key_ref: Option<PrometheusContainersEnvValueFromSecretKeyRef>,
762}
763
764#[derive(Serialize, Deserialize, Clone, Debug, Default)]
765pub struct PrometheusContainersEnvValueFromConfigMapKeyRef {
766 pub key: String,
767 #[serde(default, skip_serializing_if = "Option::is_none")]
768 pub name: Option<String>,
769 #[serde(default, skip_serializing_if = "Option::is_none")]
770 pub optional: Option<bool>,
771}
772
773#[derive(Serialize, Deserialize, Clone, Debug, Default)]
774pub struct PrometheusContainersEnvValueFromFieldRef {
775 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
776 pub api_version: Option<String>,
777 #[serde(rename = "fieldPath")]
778 pub field_path: String,
779}
780
781#[derive(Serialize, Deserialize, Clone, Debug, Default)]
782pub struct PrometheusContainersEnvValueFromResourceFieldRef {
783 #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
784 pub container_name: Option<String>,
785 #[serde(default, skip_serializing_if = "Option::is_none")]
786 pub divisor: Option<IntOrString>,
787 pub resource: String,
788}
789
790#[derive(Serialize, Deserialize, Clone, Debug, Default)]
791pub struct PrometheusContainersEnvValueFromSecretKeyRef {
792 pub key: String,
793 #[serde(default, skip_serializing_if = "Option::is_none")]
794 pub name: Option<String>,
795 #[serde(default, skip_serializing_if = "Option::is_none")]
796 pub optional: Option<bool>,
797}
798
799#[derive(Serialize, Deserialize, Clone, Debug, Default)]
800pub struct PrometheusContainersEnvFrom {
801 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapRef")]
802 pub config_map_ref: Option<PrometheusContainersEnvFromConfigMapRef>,
803 #[serde(default, skip_serializing_if = "Option::is_none")]
804 pub prefix: Option<String>,
805 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
806 pub secret_ref: Option<PrometheusContainersEnvFromSecretRef>,
807}
808
809#[derive(Serialize, Deserialize, Clone, Debug, Default)]
810pub struct PrometheusContainersEnvFromConfigMapRef {
811 #[serde(default, skip_serializing_if = "Option::is_none")]
812 pub name: Option<String>,
813 #[serde(default, skip_serializing_if = "Option::is_none")]
814 pub optional: Option<bool>,
815}
816
817#[derive(Serialize, Deserialize, Clone, Debug, Default)]
818pub struct PrometheusContainersEnvFromSecretRef {
819 #[serde(default, skip_serializing_if = "Option::is_none")]
820 pub name: Option<String>,
821 #[serde(default, skip_serializing_if = "Option::is_none")]
822 pub optional: Option<bool>,
823}
824
825#[derive(Serialize, Deserialize, Clone, Debug, Default)]
826pub struct PrometheusContainersLifecycle {
827 #[serde(default, skip_serializing_if = "Option::is_none", rename = "postStart")]
828 pub post_start: Option<PrometheusContainersLifecyclePostStart>,
829 #[serde(default, skip_serializing_if = "Option::is_none", rename = "preStop")]
830 pub pre_stop: Option<PrometheusContainersLifecyclePreStop>,
831}
832
833#[derive(Serialize, Deserialize, Clone, Debug, Default)]
834pub struct PrometheusContainersLifecyclePostStart {
835 #[serde(default, skip_serializing_if = "Option::is_none")]
836 pub exec: Option<PrometheusContainersLifecyclePostStartExec>,
837 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
838 pub http_get: Option<PrometheusContainersLifecyclePostStartHttpGet>,
839 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
840 pub tcp_socket: Option<PrometheusContainersLifecyclePostStartTcpSocket>,
841}
842
843#[derive(Serialize, Deserialize, Clone, Debug, Default)]
844pub struct PrometheusContainersLifecyclePostStartExec {
845 #[serde(default, skip_serializing_if = "Option::is_none")]
846 pub command: Option<Vec<String>>,
847}
848
849#[derive(Serialize, Deserialize, Clone, Debug, Default)]
850pub struct PrometheusContainersLifecyclePostStartHttpGet {
851 #[serde(default, skip_serializing_if = "Option::is_none")]
852 pub host: Option<String>,
853 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
854 pub http_headers: Option<Vec<PrometheusContainersLifecyclePostStartHttpGetHttpHeaders>>,
855 #[serde(default, skip_serializing_if = "Option::is_none")]
856 pub path: Option<String>,
857 pub port: IntOrString,
858 #[serde(default, skip_serializing_if = "Option::is_none")]
859 pub scheme: Option<String>,
860}
861
862#[derive(Serialize, Deserialize, Clone, Debug, Default)]
863pub struct PrometheusContainersLifecyclePostStartHttpGetHttpHeaders {
864 pub name: String,
865 pub value: String,
866}
867
868#[derive(Serialize, Deserialize, Clone, Debug, Default)]
869pub struct PrometheusContainersLifecyclePostStartTcpSocket {
870 #[serde(default, skip_serializing_if = "Option::is_none")]
871 pub host: Option<String>,
872 pub port: IntOrString,
873}
874
875#[derive(Serialize, Deserialize, Clone, Debug, Default)]
876pub struct PrometheusContainersLifecyclePreStop {
877 #[serde(default, skip_serializing_if = "Option::is_none")]
878 pub exec: Option<PrometheusContainersLifecyclePreStopExec>,
879 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
880 pub http_get: Option<PrometheusContainersLifecyclePreStopHttpGet>,
881 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
882 pub tcp_socket: Option<PrometheusContainersLifecyclePreStopTcpSocket>,
883}
884
885#[derive(Serialize, Deserialize, Clone, Debug, Default)]
886pub struct PrometheusContainersLifecyclePreStopExec {
887 #[serde(default, skip_serializing_if = "Option::is_none")]
888 pub command: Option<Vec<String>>,
889}
890
891#[derive(Serialize, Deserialize, Clone, Debug, Default)]
892pub struct PrometheusContainersLifecyclePreStopHttpGet {
893 #[serde(default, skip_serializing_if = "Option::is_none")]
894 pub host: Option<String>,
895 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
896 pub http_headers: Option<Vec<PrometheusContainersLifecyclePreStopHttpGetHttpHeaders>>,
897 #[serde(default, skip_serializing_if = "Option::is_none")]
898 pub path: Option<String>,
899 pub port: IntOrString,
900 #[serde(default, skip_serializing_if = "Option::is_none")]
901 pub scheme: Option<String>,
902}
903
904#[derive(Serialize, Deserialize, Clone, Debug, Default)]
905pub struct PrometheusContainersLifecyclePreStopHttpGetHttpHeaders {
906 pub name: String,
907 pub value: String,
908}
909
910#[derive(Serialize, Deserialize, Clone, Debug, Default)]
911pub struct PrometheusContainersLifecyclePreStopTcpSocket {
912 #[serde(default, skip_serializing_if = "Option::is_none")]
913 pub host: Option<String>,
914 pub port: IntOrString,
915}
916
917#[derive(Serialize, Deserialize, Clone, Debug, Default)]
918pub struct PrometheusContainersLivenessProbe {
919 #[serde(default, skip_serializing_if = "Option::is_none")]
920 pub exec: Option<PrometheusContainersLivenessProbeExec>,
921 #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
922 pub failure_threshold: Option<i32>,
923 #[serde(default, skip_serializing_if = "Option::is_none")]
924 pub grpc: Option<PrometheusContainersLivenessProbeGrpc>,
925 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
926 pub http_get: Option<PrometheusContainersLivenessProbeHttpGet>,
927 #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
928 pub initial_delay_seconds: Option<i32>,
929 #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
930 pub period_seconds: Option<i32>,
931 #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
932 pub success_threshold: Option<i32>,
933 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
934 pub tcp_socket: Option<PrometheusContainersLivenessProbeTcpSocket>,
935 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
936 pub termination_grace_period_seconds: Option<i64>,
937 #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
938 pub timeout_seconds: Option<i32>,
939}
940
941#[derive(Serialize, Deserialize, Clone, Debug, Default)]
942pub struct PrometheusContainersLivenessProbeExec {
943 #[serde(default, skip_serializing_if = "Option::is_none")]
944 pub command: Option<Vec<String>>,
945}
946
947#[derive(Serialize, Deserialize, Clone, Debug, Default)]
948pub struct PrometheusContainersLivenessProbeGrpc {
949 pub port: i32,
950 #[serde(default, skip_serializing_if = "Option::is_none")]
951 pub service: Option<String>,
952}
953
954#[derive(Serialize, Deserialize, Clone, Debug, Default)]
955pub struct PrometheusContainersLivenessProbeHttpGet {
956 #[serde(default, skip_serializing_if = "Option::is_none")]
957 pub host: Option<String>,
958 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
959 pub http_headers: Option<Vec<PrometheusContainersLivenessProbeHttpGetHttpHeaders>>,
960 #[serde(default, skip_serializing_if = "Option::is_none")]
961 pub path: Option<String>,
962 pub port: IntOrString,
963 #[serde(default, skip_serializing_if = "Option::is_none")]
964 pub scheme: Option<String>,
965}
966
967#[derive(Serialize, Deserialize, Clone, Debug, Default)]
968pub struct PrometheusContainersLivenessProbeHttpGetHttpHeaders {
969 pub name: String,
970 pub value: String,
971}
972
973#[derive(Serialize, Deserialize, Clone, Debug, Default)]
974pub struct PrometheusContainersLivenessProbeTcpSocket {
975 #[serde(default, skip_serializing_if = "Option::is_none")]
976 pub host: Option<String>,
977 pub port: IntOrString,
978}
979
980#[derive(Serialize, Deserialize, Clone, Debug, Default)]
981pub struct PrometheusContainersPorts {
982 #[serde(rename = "containerPort")]
983 pub container_port: i32,
984 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostIP")]
985 pub host_ip: Option<String>,
986 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostPort")]
987 pub host_port: Option<i32>,
988 #[serde(default, skip_serializing_if = "Option::is_none")]
989 pub name: Option<String>,
990 #[serde(default, skip_serializing_if = "Option::is_none")]
991 pub protocol: Option<String>,
992}
993
994#[derive(Serialize, Deserialize, Clone, Debug, Default)]
995pub struct PrometheusContainersReadinessProbe {
996 #[serde(default, skip_serializing_if = "Option::is_none")]
997 pub exec: Option<PrometheusContainersReadinessProbeExec>,
998 #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
999 pub failure_threshold: Option<i32>,
1000 #[serde(default, skip_serializing_if = "Option::is_none")]
1001 pub grpc: Option<PrometheusContainersReadinessProbeGrpc>,
1002 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
1003 pub http_get: Option<PrometheusContainersReadinessProbeHttpGet>,
1004 #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
1005 pub initial_delay_seconds: Option<i32>,
1006 #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
1007 pub period_seconds: Option<i32>,
1008 #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
1009 pub success_threshold: Option<i32>,
1010 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
1011 pub tcp_socket: Option<PrometheusContainersReadinessProbeTcpSocket>,
1012 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
1013 pub termination_grace_period_seconds: Option<i64>,
1014 #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
1015 pub timeout_seconds: Option<i32>,
1016}
1017
1018#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1019pub struct PrometheusContainersReadinessProbeExec {
1020 #[serde(default, skip_serializing_if = "Option::is_none")]
1021 pub command: Option<Vec<String>>,
1022}
1023
1024#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1025pub struct PrometheusContainersReadinessProbeGrpc {
1026 pub port: i32,
1027 #[serde(default, skip_serializing_if = "Option::is_none")]
1028 pub service: Option<String>,
1029}
1030
1031#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1032pub struct PrometheusContainersReadinessProbeHttpGet {
1033 #[serde(default, skip_serializing_if = "Option::is_none")]
1034 pub host: Option<String>,
1035 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
1036 pub http_headers: Option<Vec<PrometheusContainersReadinessProbeHttpGetHttpHeaders>>,
1037 #[serde(default, skip_serializing_if = "Option::is_none")]
1038 pub path: Option<String>,
1039 pub port: IntOrString,
1040 #[serde(default, skip_serializing_if = "Option::is_none")]
1041 pub scheme: Option<String>,
1042}
1043
1044#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1045pub struct PrometheusContainersReadinessProbeHttpGetHttpHeaders {
1046 pub name: String,
1047 pub value: String,
1048}
1049
1050#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1051pub struct PrometheusContainersReadinessProbeTcpSocket {
1052 #[serde(default, skip_serializing_if = "Option::is_none")]
1053 pub host: Option<String>,
1054 pub port: IntOrString,
1055}
1056
1057#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1058pub struct PrometheusContainersResizePolicy {
1059 #[serde(rename = "resourceName")]
1060 pub resource_name: String,
1061 #[serde(rename = "restartPolicy")]
1062 pub restart_policy: String,
1063}
1064
1065#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1066pub struct PrometheusContainersResources {
1067 #[serde(default, skip_serializing_if = "Option::is_none")]
1068 pub claims: Option<Vec<PrometheusContainersResourcesClaims>>,
1069 #[serde(default, skip_serializing_if = "Option::is_none")]
1070 pub limits: Option<BTreeMap<String, IntOrString>>,
1071 #[serde(default, skip_serializing_if = "Option::is_none")]
1072 pub requests: Option<BTreeMap<String, IntOrString>>,
1073}
1074
1075#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1076pub struct PrometheusContainersResourcesClaims {
1077 pub name: String,
1078}
1079
1080#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1081pub struct PrometheusContainersSecurityContext {
1082 #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowPrivilegeEscalation")]
1083 pub allow_privilege_escalation: Option<bool>,
1084 #[serde(default, skip_serializing_if = "Option::is_none")]
1085 pub capabilities: Option<PrometheusContainersSecurityContextCapabilities>,
1086 #[serde(default, skip_serializing_if = "Option::is_none")]
1087 pub privileged: Option<bool>,
1088 #[serde(default, skip_serializing_if = "Option::is_none", rename = "procMount")]
1089 pub proc_mount: Option<String>,
1090 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnlyRootFilesystem")]
1091 pub read_only_root_filesystem: Option<bool>,
1092 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
1093 pub run_as_group: Option<i64>,
1094 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
1095 pub run_as_non_root: Option<bool>,
1096 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
1097 pub run_as_user: Option<i64>,
1098 #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
1099 pub se_linux_options: Option<PrometheusContainersSecurityContextSeLinuxOptions>,
1100 #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
1101 pub seccomp_profile: Option<PrometheusContainersSecurityContextSeccompProfile>,
1102 #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
1103 pub windows_options: Option<PrometheusContainersSecurityContextWindowsOptions>,
1104}
1105
1106#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1107pub struct PrometheusContainersSecurityContextCapabilities {
1108 #[serde(default, skip_serializing_if = "Option::is_none")]
1109 pub add: Option<Vec<String>>,
1110 #[serde(default, skip_serializing_if = "Option::is_none")]
1111 pub drop: Option<Vec<String>>,
1112}
1113
1114#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1115pub struct PrometheusContainersSecurityContextSeLinuxOptions {
1116 #[serde(default, skip_serializing_if = "Option::is_none")]
1117 pub level: Option<String>,
1118 #[serde(default, skip_serializing_if = "Option::is_none")]
1119 pub role: Option<String>,
1120 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
1121 pub r#type: Option<String>,
1122 #[serde(default, skip_serializing_if = "Option::is_none")]
1123 pub user: Option<String>,
1124}
1125
1126#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1127pub struct PrometheusContainersSecurityContextSeccompProfile {
1128 #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
1129 pub localhost_profile: Option<String>,
1130 #[serde(rename = "type")]
1131 pub r#type: String,
1132}
1133
1134#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1135pub struct PrometheusContainersSecurityContextWindowsOptions {
1136 #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
1137 pub gmsa_credential_spec: Option<String>,
1138 #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
1139 pub gmsa_credential_spec_name: Option<String>,
1140 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
1141 pub host_process: Option<bool>,
1142 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
1143 pub run_as_user_name: Option<String>,
1144}
1145
1146#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1147pub struct PrometheusContainersStartupProbe {
1148 #[serde(default, skip_serializing_if = "Option::is_none")]
1149 pub exec: Option<PrometheusContainersStartupProbeExec>,
1150 #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
1151 pub failure_threshold: Option<i32>,
1152 #[serde(default, skip_serializing_if = "Option::is_none")]
1153 pub grpc: Option<PrometheusContainersStartupProbeGrpc>,
1154 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
1155 pub http_get: Option<PrometheusContainersStartupProbeHttpGet>,
1156 #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
1157 pub initial_delay_seconds: Option<i32>,
1158 #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
1159 pub period_seconds: Option<i32>,
1160 #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
1161 pub success_threshold: Option<i32>,
1162 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
1163 pub tcp_socket: Option<PrometheusContainersStartupProbeTcpSocket>,
1164 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
1165 pub termination_grace_period_seconds: Option<i64>,
1166 #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
1167 pub timeout_seconds: Option<i32>,
1168}
1169
1170#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1171pub struct PrometheusContainersStartupProbeExec {
1172 #[serde(default, skip_serializing_if = "Option::is_none")]
1173 pub command: Option<Vec<String>>,
1174}
1175
1176#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1177pub struct PrometheusContainersStartupProbeGrpc {
1178 pub port: i32,
1179 #[serde(default, skip_serializing_if = "Option::is_none")]
1180 pub service: Option<String>,
1181}
1182
1183#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1184pub struct PrometheusContainersStartupProbeHttpGet {
1185 #[serde(default, skip_serializing_if = "Option::is_none")]
1186 pub host: Option<String>,
1187 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
1188 pub http_headers: Option<Vec<PrometheusContainersStartupProbeHttpGetHttpHeaders>>,
1189 #[serde(default, skip_serializing_if = "Option::is_none")]
1190 pub path: Option<String>,
1191 pub port: IntOrString,
1192 #[serde(default, skip_serializing_if = "Option::is_none")]
1193 pub scheme: Option<String>,
1194}
1195
1196#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1197pub struct PrometheusContainersStartupProbeHttpGetHttpHeaders {
1198 pub name: String,
1199 pub value: String,
1200}
1201
1202#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1203pub struct PrometheusContainersStartupProbeTcpSocket {
1204 #[serde(default, skip_serializing_if = "Option::is_none")]
1205 pub host: Option<String>,
1206 pub port: IntOrString,
1207}
1208
1209#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1210pub struct PrometheusContainersVolumeDevices {
1211 #[serde(rename = "devicePath")]
1212 pub device_path: String,
1213 pub name: String,
1214}
1215
1216#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1217pub struct PrometheusContainersVolumeMounts {
1218 #[serde(rename = "mountPath")]
1219 pub mount_path: String,
1220 #[serde(default, skip_serializing_if = "Option::is_none", rename = "mountPropagation")]
1221 pub mount_propagation: Option<String>,
1222 pub name: String,
1223 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
1224 pub read_only: Option<bool>,
1225 #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPath")]
1226 pub sub_path: Option<String>,
1227 #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPathExpr")]
1228 pub sub_path_expr: Option<String>,
1229}
1230
1231#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1232pub struct PrometheusExcludedFromEnforcement {
1233 #[serde(default, skip_serializing_if = "Option::is_none")]
1234 pub group: Option<PrometheusExcludedFromEnforcementGroup>,
1235 #[serde(default, skip_serializing_if = "Option::is_none")]
1236 pub name: Option<String>,
1237 pub namespace: String,
1238 pub resource: String,
1239}
1240
1241#[derive(Serialize, Deserialize, Clone, Debug)]
1242pub enum PrometheusExcludedFromEnforcementGroup {
1243 #[serde(rename = "monitoring.coreos.com")]
1244 MonitoringCoreosCom,
1245}
1246
1247#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1248pub struct PrometheusExemplars {
1249 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxSize")]
1250 pub max_size: Option<i64>,
1251}
1252
1253#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1254pub struct PrometheusHostAliases {
1255 pub hostnames: Vec<String>,
1256 pub ip: String,
1257}
1258
1259#[derive(Serialize, Deserialize, Clone, Debug)]
1260pub enum PrometheusImagePullPolicy {
1261 #[serde(rename = "")]
1262 KopiumEmpty,
1263 Always,
1264 Never,
1265 IfNotPresent,
1266}
1267
1268#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1269pub struct PrometheusImagePullSecrets {
1270 #[serde(default, skip_serializing_if = "Option::is_none")]
1271 pub name: Option<String>,
1272}
1273
1274#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1275pub struct PrometheusInitContainers {
1276 #[serde(default, skip_serializing_if = "Option::is_none")]
1277 pub args: Option<Vec<String>>,
1278 #[serde(default, skip_serializing_if = "Option::is_none")]
1279 pub command: Option<Vec<String>>,
1280 #[serde(default, skip_serializing_if = "Option::is_none")]
1281 pub env: Option<Vec<PrometheusInitContainersEnv>>,
1282 #[serde(default, skip_serializing_if = "Option::is_none", rename = "envFrom")]
1283 pub env_from: Option<Vec<PrometheusInitContainersEnvFrom>>,
1284 #[serde(default, skip_serializing_if = "Option::is_none")]
1285 pub image: Option<String>,
1286 #[serde(default, skip_serializing_if = "Option::is_none", rename = "imagePullPolicy")]
1287 pub image_pull_policy: Option<String>,
1288 #[serde(default, skip_serializing_if = "Option::is_none")]
1289 pub lifecycle: Option<PrometheusInitContainersLifecycle>,
1290 #[serde(default, skip_serializing_if = "Option::is_none", rename = "livenessProbe")]
1291 pub liveness_probe: Option<PrometheusInitContainersLivenessProbe>,
1292 pub name: String,
1293 #[serde(default, skip_serializing_if = "Option::is_none")]
1294 pub ports: Option<Vec<PrometheusInitContainersPorts>>,
1295 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readinessProbe")]
1296 pub readiness_probe: Option<PrometheusInitContainersReadinessProbe>,
1297 #[serde(default, skip_serializing_if = "Option::is_none", rename = "resizePolicy")]
1298 pub resize_policy: Option<Vec<PrometheusInitContainersResizePolicy>>,
1299 #[serde(default, skip_serializing_if = "Option::is_none")]
1300 pub resources: Option<PrometheusInitContainersResources>,
1301 #[serde(default, skip_serializing_if = "Option::is_none", rename = "securityContext")]
1302 pub security_context: Option<PrometheusInitContainersSecurityContext>,
1303 #[serde(default, skip_serializing_if = "Option::is_none", rename = "startupProbe")]
1304 pub startup_probe: Option<PrometheusInitContainersStartupProbe>,
1305 #[serde(default, skip_serializing_if = "Option::is_none")]
1306 pub stdin: Option<bool>,
1307 #[serde(default, skip_serializing_if = "Option::is_none", rename = "stdinOnce")]
1308 pub stdin_once: Option<bool>,
1309 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationMessagePath")]
1310 pub termination_message_path: Option<String>,
1311 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationMessagePolicy")]
1312 pub termination_message_policy: Option<String>,
1313 #[serde(default, skip_serializing_if = "Option::is_none")]
1314 pub tty: Option<bool>,
1315 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeDevices")]
1316 pub volume_devices: Option<Vec<PrometheusInitContainersVolumeDevices>>,
1317 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
1318 pub volume_mounts: Option<Vec<PrometheusInitContainersVolumeMounts>>,
1319 #[serde(default, skip_serializing_if = "Option::is_none", rename = "workingDir")]
1320 pub working_dir: Option<String>,
1321}
1322
1323#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1324pub struct PrometheusInitContainersEnv {
1325 pub name: String,
1326 #[serde(default, skip_serializing_if = "Option::is_none")]
1327 pub value: Option<String>,
1328 #[serde(default, skip_serializing_if = "Option::is_none", rename = "valueFrom")]
1329 pub value_from: Option<PrometheusInitContainersEnvValueFrom>,
1330}
1331
1332#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1333pub struct PrometheusInitContainersEnvValueFrom {
1334 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapKeyRef")]
1335 pub config_map_key_ref: Option<PrometheusInitContainersEnvValueFromConfigMapKeyRef>,
1336 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
1337 pub field_ref: Option<PrometheusInitContainersEnvValueFromFieldRef>,
1338 #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
1339 pub resource_field_ref: Option<PrometheusInitContainersEnvValueFromResourceFieldRef>,
1340 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKeyRef")]
1341 pub secret_key_ref: Option<PrometheusInitContainersEnvValueFromSecretKeyRef>,
1342}
1343
1344#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1345pub struct PrometheusInitContainersEnvValueFromConfigMapKeyRef {
1346 pub key: String,
1347 #[serde(default, skip_serializing_if = "Option::is_none")]
1348 pub name: Option<String>,
1349 #[serde(default, skip_serializing_if = "Option::is_none")]
1350 pub optional: Option<bool>,
1351}
1352
1353#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1354pub struct PrometheusInitContainersEnvValueFromFieldRef {
1355 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
1356 pub api_version: Option<String>,
1357 #[serde(rename = "fieldPath")]
1358 pub field_path: String,
1359}
1360
1361#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1362pub struct PrometheusInitContainersEnvValueFromResourceFieldRef {
1363 #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
1364 pub container_name: Option<String>,
1365 #[serde(default, skip_serializing_if = "Option::is_none")]
1366 pub divisor: Option<IntOrString>,
1367 pub resource: String,
1368}
1369
1370#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1371pub struct PrometheusInitContainersEnvValueFromSecretKeyRef {
1372 pub key: String,
1373 #[serde(default, skip_serializing_if = "Option::is_none")]
1374 pub name: Option<String>,
1375 #[serde(default, skip_serializing_if = "Option::is_none")]
1376 pub optional: Option<bool>,
1377}
1378
1379#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1380pub struct PrometheusInitContainersEnvFrom {
1381 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMapRef")]
1382 pub config_map_ref: Option<PrometheusInitContainersEnvFromConfigMapRef>,
1383 #[serde(default, skip_serializing_if = "Option::is_none")]
1384 pub prefix: Option<String>,
1385 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
1386 pub secret_ref: Option<PrometheusInitContainersEnvFromSecretRef>,
1387}
1388
1389#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1390pub struct PrometheusInitContainersEnvFromConfigMapRef {
1391 #[serde(default, skip_serializing_if = "Option::is_none")]
1392 pub name: Option<String>,
1393 #[serde(default, skip_serializing_if = "Option::is_none")]
1394 pub optional: Option<bool>,
1395}
1396
1397#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1398pub struct PrometheusInitContainersEnvFromSecretRef {
1399 #[serde(default, skip_serializing_if = "Option::is_none")]
1400 pub name: Option<String>,
1401 #[serde(default, skip_serializing_if = "Option::is_none")]
1402 pub optional: Option<bool>,
1403}
1404
1405#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1406pub struct PrometheusInitContainersLifecycle {
1407 #[serde(default, skip_serializing_if = "Option::is_none", rename = "postStart")]
1408 pub post_start: Option<PrometheusInitContainersLifecyclePostStart>,
1409 #[serde(default, skip_serializing_if = "Option::is_none", rename = "preStop")]
1410 pub pre_stop: Option<PrometheusInitContainersLifecyclePreStop>,
1411}
1412
1413#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1414pub struct PrometheusInitContainersLifecyclePostStart {
1415 #[serde(default, skip_serializing_if = "Option::is_none")]
1416 pub exec: Option<PrometheusInitContainersLifecyclePostStartExec>,
1417 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
1418 pub http_get: Option<PrometheusInitContainersLifecyclePostStartHttpGet>,
1419 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
1420 pub tcp_socket: Option<PrometheusInitContainersLifecyclePostStartTcpSocket>,
1421}
1422
1423#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1424pub struct PrometheusInitContainersLifecyclePostStartExec {
1425 #[serde(default, skip_serializing_if = "Option::is_none")]
1426 pub command: Option<Vec<String>>,
1427}
1428
1429#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1430pub struct PrometheusInitContainersLifecyclePostStartHttpGet {
1431 #[serde(default, skip_serializing_if = "Option::is_none")]
1432 pub host: Option<String>,
1433 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
1434 pub http_headers: Option<Vec<PrometheusInitContainersLifecyclePostStartHttpGetHttpHeaders>>,
1435 #[serde(default, skip_serializing_if = "Option::is_none")]
1436 pub path: Option<String>,
1437 pub port: IntOrString,
1438 #[serde(default, skip_serializing_if = "Option::is_none")]
1439 pub scheme: Option<String>,
1440}
1441
1442#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1443pub struct PrometheusInitContainersLifecyclePostStartHttpGetHttpHeaders {
1444 pub name: String,
1445 pub value: String,
1446}
1447
1448#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1449pub struct PrometheusInitContainersLifecyclePostStartTcpSocket {
1450 #[serde(default, skip_serializing_if = "Option::is_none")]
1451 pub host: Option<String>,
1452 pub port: IntOrString,
1453}
1454
1455#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1456pub struct PrometheusInitContainersLifecyclePreStop {
1457 #[serde(default, skip_serializing_if = "Option::is_none")]
1458 pub exec: Option<PrometheusInitContainersLifecyclePreStopExec>,
1459 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
1460 pub http_get: Option<PrometheusInitContainersLifecyclePreStopHttpGet>,
1461 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
1462 pub tcp_socket: Option<PrometheusInitContainersLifecyclePreStopTcpSocket>,
1463}
1464
1465#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1466pub struct PrometheusInitContainersLifecyclePreStopExec {
1467 #[serde(default, skip_serializing_if = "Option::is_none")]
1468 pub command: Option<Vec<String>>,
1469}
1470
1471#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1472pub struct PrometheusInitContainersLifecyclePreStopHttpGet {
1473 #[serde(default, skip_serializing_if = "Option::is_none")]
1474 pub host: Option<String>,
1475 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
1476 pub http_headers: Option<Vec<PrometheusInitContainersLifecyclePreStopHttpGetHttpHeaders>>,
1477 #[serde(default, skip_serializing_if = "Option::is_none")]
1478 pub path: Option<String>,
1479 pub port: IntOrString,
1480 #[serde(default, skip_serializing_if = "Option::is_none")]
1481 pub scheme: Option<String>,
1482}
1483
1484#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1485pub struct PrometheusInitContainersLifecyclePreStopHttpGetHttpHeaders {
1486 pub name: String,
1487 pub value: String,
1488}
1489
1490#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1491pub struct PrometheusInitContainersLifecyclePreStopTcpSocket {
1492 #[serde(default, skip_serializing_if = "Option::is_none")]
1493 pub host: Option<String>,
1494 pub port: IntOrString,
1495}
1496
1497#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1498pub struct PrometheusInitContainersLivenessProbe {
1499 #[serde(default, skip_serializing_if = "Option::is_none")]
1500 pub exec: Option<PrometheusInitContainersLivenessProbeExec>,
1501 #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
1502 pub failure_threshold: Option<i32>,
1503 #[serde(default, skip_serializing_if = "Option::is_none")]
1504 pub grpc: Option<PrometheusInitContainersLivenessProbeGrpc>,
1505 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
1506 pub http_get: Option<PrometheusInitContainersLivenessProbeHttpGet>,
1507 #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
1508 pub initial_delay_seconds: Option<i32>,
1509 #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
1510 pub period_seconds: Option<i32>,
1511 #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
1512 pub success_threshold: Option<i32>,
1513 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
1514 pub tcp_socket: Option<PrometheusInitContainersLivenessProbeTcpSocket>,
1515 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
1516 pub termination_grace_period_seconds: Option<i64>,
1517 #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
1518 pub timeout_seconds: Option<i32>,
1519}
1520
1521#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1522pub struct PrometheusInitContainersLivenessProbeExec {
1523 #[serde(default, skip_serializing_if = "Option::is_none")]
1524 pub command: Option<Vec<String>>,
1525}
1526
1527#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1528pub struct PrometheusInitContainersLivenessProbeGrpc {
1529 pub port: i32,
1530 #[serde(default, skip_serializing_if = "Option::is_none")]
1531 pub service: Option<String>,
1532}
1533
1534#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1535pub struct PrometheusInitContainersLivenessProbeHttpGet {
1536 #[serde(default, skip_serializing_if = "Option::is_none")]
1537 pub host: Option<String>,
1538 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
1539 pub http_headers: Option<Vec<PrometheusInitContainersLivenessProbeHttpGetHttpHeaders>>,
1540 #[serde(default, skip_serializing_if = "Option::is_none")]
1541 pub path: Option<String>,
1542 pub port: IntOrString,
1543 #[serde(default, skip_serializing_if = "Option::is_none")]
1544 pub scheme: Option<String>,
1545}
1546
1547#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1548pub struct PrometheusInitContainersLivenessProbeHttpGetHttpHeaders {
1549 pub name: String,
1550 pub value: String,
1551}
1552
1553#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1554pub struct PrometheusInitContainersLivenessProbeTcpSocket {
1555 #[serde(default, skip_serializing_if = "Option::is_none")]
1556 pub host: Option<String>,
1557 pub port: IntOrString,
1558}
1559
1560#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1561pub struct PrometheusInitContainersPorts {
1562 #[serde(rename = "containerPort")]
1563 pub container_port: i32,
1564 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostIP")]
1565 pub host_ip: Option<String>,
1566 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostPort")]
1567 pub host_port: Option<i32>,
1568 #[serde(default, skip_serializing_if = "Option::is_none")]
1569 pub name: Option<String>,
1570 #[serde(default, skip_serializing_if = "Option::is_none")]
1571 pub protocol: Option<String>,
1572}
1573
1574#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1575pub struct PrometheusInitContainersReadinessProbe {
1576 #[serde(default, skip_serializing_if = "Option::is_none")]
1577 pub exec: Option<PrometheusInitContainersReadinessProbeExec>,
1578 #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
1579 pub failure_threshold: Option<i32>,
1580 #[serde(default, skip_serializing_if = "Option::is_none")]
1581 pub grpc: Option<PrometheusInitContainersReadinessProbeGrpc>,
1582 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
1583 pub http_get: Option<PrometheusInitContainersReadinessProbeHttpGet>,
1584 #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
1585 pub initial_delay_seconds: Option<i32>,
1586 #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
1587 pub period_seconds: Option<i32>,
1588 #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
1589 pub success_threshold: Option<i32>,
1590 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
1591 pub tcp_socket: Option<PrometheusInitContainersReadinessProbeTcpSocket>,
1592 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
1593 pub termination_grace_period_seconds: Option<i64>,
1594 #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
1595 pub timeout_seconds: Option<i32>,
1596}
1597
1598#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1599pub struct PrometheusInitContainersReadinessProbeExec {
1600 #[serde(default, skip_serializing_if = "Option::is_none")]
1601 pub command: Option<Vec<String>>,
1602}
1603
1604#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1605pub struct PrometheusInitContainersReadinessProbeGrpc {
1606 pub port: i32,
1607 #[serde(default, skip_serializing_if = "Option::is_none")]
1608 pub service: Option<String>,
1609}
1610
1611#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1612pub struct PrometheusInitContainersReadinessProbeHttpGet {
1613 #[serde(default, skip_serializing_if = "Option::is_none")]
1614 pub host: Option<String>,
1615 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
1616 pub http_headers: Option<Vec<PrometheusInitContainersReadinessProbeHttpGetHttpHeaders>>,
1617 #[serde(default, skip_serializing_if = "Option::is_none")]
1618 pub path: Option<String>,
1619 pub port: IntOrString,
1620 #[serde(default, skip_serializing_if = "Option::is_none")]
1621 pub scheme: Option<String>,
1622}
1623
1624#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1625pub struct PrometheusInitContainersReadinessProbeHttpGetHttpHeaders {
1626 pub name: String,
1627 pub value: String,
1628}
1629
1630#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1631pub struct PrometheusInitContainersReadinessProbeTcpSocket {
1632 #[serde(default, skip_serializing_if = "Option::is_none")]
1633 pub host: Option<String>,
1634 pub port: IntOrString,
1635}
1636
1637#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1638pub struct PrometheusInitContainersResizePolicy {
1639 #[serde(rename = "resourceName")]
1640 pub resource_name: String,
1641 #[serde(rename = "restartPolicy")]
1642 pub restart_policy: String,
1643}
1644
1645#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1646pub struct PrometheusInitContainersResources {
1647 #[serde(default, skip_serializing_if = "Option::is_none")]
1648 pub claims: Option<Vec<PrometheusInitContainersResourcesClaims>>,
1649 #[serde(default, skip_serializing_if = "Option::is_none")]
1650 pub limits: Option<BTreeMap<String, IntOrString>>,
1651 #[serde(default, skip_serializing_if = "Option::is_none")]
1652 pub requests: Option<BTreeMap<String, IntOrString>>,
1653}
1654
1655#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1656pub struct PrometheusInitContainersResourcesClaims {
1657 pub name: String,
1658}
1659
1660#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1661pub struct PrometheusInitContainersSecurityContext {
1662 #[serde(default, skip_serializing_if = "Option::is_none", rename = "allowPrivilegeEscalation")]
1663 pub allow_privilege_escalation: Option<bool>,
1664 #[serde(default, skip_serializing_if = "Option::is_none")]
1665 pub capabilities: Option<PrometheusInitContainersSecurityContextCapabilities>,
1666 #[serde(default, skip_serializing_if = "Option::is_none")]
1667 pub privileged: Option<bool>,
1668 #[serde(default, skip_serializing_if = "Option::is_none", rename = "procMount")]
1669 pub proc_mount: Option<String>,
1670 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnlyRootFilesystem")]
1671 pub read_only_root_filesystem: Option<bool>,
1672 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
1673 pub run_as_group: Option<i64>,
1674 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
1675 pub run_as_non_root: Option<bool>,
1676 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
1677 pub run_as_user: Option<i64>,
1678 #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
1679 pub se_linux_options: Option<PrometheusInitContainersSecurityContextSeLinuxOptions>,
1680 #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
1681 pub seccomp_profile: Option<PrometheusInitContainersSecurityContextSeccompProfile>,
1682 #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
1683 pub windows_options: Option<PrometheusInitContainersSecurityContextWindowsOptions>,
1684}
1685
1686#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1687pub struct PrometheusInitContainersSecurityContextCapabilities {
1688 #[serde(default, skip_serializing_if = "Option::is_none")]
1689 pub add: Option<Vec<String>>,
1690 #[serde(default, skip_serializing_if = "Option::is_none")]
1691 pub drop: Option<Vec<String>>,
1692}
1693
1694#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1695pub struct PrometheusInitContainersSecurityContextSeLinuxOptions {
1696 #[serde(default, skip_serializing_if = "Option::is_none")]
1697 pub level: Option<String>,
1698 #[serde(default, skip_serializing_if = "Option::is_none")]
1699 pub role: Option<String>,
1700 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
1701 pub r#type: Option<String>,
1702 #[serde(default, skip_serializing_if = "Option::is_none")]
1703 pub user: Option<String>,
1704}
1705
1706#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1707pub struct PrometheusInitContainersSecurityContextSeccompProfile {
1708 #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
1709 pub localhost_profile: Option<String>,
1710 #[serde(rename = "type")]
1711 pub r#type: String,
1712}
1713
1714#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1715pub struct PrometheusInitContainersSecurityContextWindowsOptions {
1716 #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
1717 pub gmsa_credential_spec: Option<String>,
1718 #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
1719 pub gmsa_credential_spec_name: Option<String>,
1720 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
1721 pub host_process: Option<bool>,
1722 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
1723 pub run_as_user_name: Option<String>,
1724}
1725
1726#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1727pub struct PrometheusInitContainersStartupProbe {
1728 #[serde(default, skip_serializing_if = "Option::is_none")]
1729 pub exec: Option<PrometheusInitContainersStartupProbeExec>,
1730 #[serde(default, skip_serializing_if = "Option::is_none", rename = "failureThreshold")]
1731 pub failure_threshold: Option<i32>,
1732 #[serde(default, skip_serializing_if = "Option::is_none")]
1733 pub grpc: Option<PrometheusInitContainersStartupProbeGrpc>,
1734 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpGet")]
1735 pub http_get: Option<PrometheusInitContainersStartupProbeHttpGet>,
1736 #[serde(default, skip_serializing_if = "Option::is_none", rename = "initialDelaySeconds")]
1737 pub initial_delay_seconds: Option<i32>,
1738 #[serde(default, skip_serializing_if = "Option::is_none", rename = "periodSeconds")]
1739 pub period_seconds: Option<i32>,
1740 #[serde(default, skip_serializing_if = "Option::is_none", rename = "successThreshold")]
1741 pub success_threshold: Option<i32>,
1742 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tcpSocket")]
1743 pub tcp_socket: Option<PrometheusInitContainersStartupProbeTcpSocket>,
1744 #[serde(default, skip_serializing_if = "Option::is_none", rename = "terminationGracePeriodSeconds")]
1745 pub termination_grace_period_seconds: Option<i64>,
1746 #[serde(default, skip_serializing_if = "Option::is_none", rename = "timeoutSeconds")]
1747 pub timeout_seconds: Option<i32>,
1748}
1749
1750#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1751pub struct PrometheusInitContainersStartupProbeExec {
1752 #[serde(default, skip_serializing_if = "Option::is_none")]
1753 pub command: Option<Vec<String>>,
1754}
1755
1756#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1757pub struct PrometheusInitContainersStartupProbeGrpc {
1758 pub port: i32,
1759 #[serde(default, skip_serializing_if = "Option::is_none")]
1760 pub service: Option<String>,
1761}
1762
1763#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1764pub struct PrometheusInitContainersStartupProbeHttpGet {
1765 #[serde(default, skip_serializing_if = "Option::is_none")]
1766 pub host: Option<String>,
1767 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpHeaders")]
1768 pub http_headers: Option<Vec<PrometheusInitContainersStartupProbeHttpGetHttpHeaders>>,
1769 #[serde(default, skip_serializing_if = "Option::is_none")]
1770 pub path: Option<String>,
1771 pub port: IntOrString,
1772 #[serde(default, skip_serializing_if = "Option::is_none")]
1773 pub scheme: Option<String>,
1774}
1775
1776#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1777pub struct PrometheusInitContainersStartupProbeHttpGetHttpHeaders {
1778 pub name: String,
1779 pub value: String,
1780}
1781
1782#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1783pub struct PrometheusInitContainersStartupProbeTcpSocket {
1784 #[serde(default, skip_serializing_if = "Option::is_none")]
1785 pub host: Option<String>,
1786 pub port: IntOrString,
1787}
1788
1789#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1790pub struct PrometheusInitContainersVolumeDevices {
1791 #[serde(rename = "devicePath")]
1792 pub device_path: String,
1793 pub name: String,
1794}
1795
1796#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1797pub struct PrometheusInitContainersVolumeMounts {
1798 #[serde(rename = "mountPath")]
1799 pub mount_path: String,
1800 #[serde(default, skip_serializing_if = "Option::is_none", rename = "mountPropagation")]
1801 pub mount_propagation: Option<String>,
1802 pub name: String,
1803 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
1804 pub read_only: Option<bool>,
1805 #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPath")]
1806 pub sub_path: Option<String>,
1807 #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPathExpr")]
1808 pub sub_path_expr: Option<String>,
1809}
1810
1811#[derive(Serialize, Deserialize, Clone, Debug)]
1812pub enum PrometheusLogFormat {
1813 #[serde(rename = "")]
1814 KopiumEmpty,
1815 #[serde(rename = "logfmt")]
1816 Logfmt,
1817 #[serde(rename = "json")]
1818 Json,
1819}
1820
1821#[derive(Serialize, Deserialize, Clone, Debug)]
1822pub enum PrometheusLogLevel {
1823 #[serde(rename = "")]
1824 KopiumEmpty,
1825 #[serde(rename = "debug")]
1826 Debug,
1827 #[serde(rename = "info")]
1828 Info,
1829 #[serde(rename = "warn")]
1830 Warn,
1831 #[serde(rename = "error")]
1832 Error,
1833}
1834
1835#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1836pub struct PrometheusPodMetadata {
1837 #[serde(default, skip_serializing_if = "Option::is_none")]
1838 pub annotations: Option<BTreeMap<String, String>>,
1839 #[serde(default, skip_serializing_if = "Option::is_none")]
1840 pub labels: Option<BTreeMap<String, String>>,
1841 #[serde(default, skip_serializing_if = "Option::is_none")]
1842 pub name: Option<String>,
1843}
1844
1845#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1846pub struct PrometheusPrometheusRulesExcludedFromEnforce {
1847 #[serde(rename = "ruleName")]
1848 pub rule_name: String,
1849 #[serde(rename = "ruleNamespace")]
1850 pub rule_namespace: String,
1851}
1852
1853#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1854pub struct PrometheusQuery {
1855 #[serde(default, skip_serializing_if = "Option::is_none", rename = "lookbackDelta")]
1856 pub lookback_delta: Option<String>,
1857 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxConcurrency")]
1858 pub max_concurrency: Option<i32>,
1859 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxSamples")]
1860 pub max_samples: Option<i32>,
1861 #[serde(default, skip_serializing_if = "Option::is_none")]
1862 pub timeout: Option<String>,
1863}
1864
1865#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1866pub struct PrometheusRemoteRead {
1867 #[serde(default, skip_serializing_if = "Option::is_none")]
1868 pub authorization: Option<PrometheusRemoteReadAuthorization>,
1869 #[serde(default, skip_serializing_if = "Option::is_none", rename = "basicAuth")]
1870 pub basic_auth: Option<PrometheusRemoteReadBasicAuth>,
1871 #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerToken")]
1872 pub bearer_token: Option<String>,
1873 #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerTokenFile")]
1874 pub bearer_token_file: Option<String>,
1875 #[serde(default, skip_serializing_if = "Option::is_none", rename = "filterExternalLabels")]
1876 pub filter_external_labels: Option<bool>,
1877 #[serde(default, skip_serializing_if = "Option::is_none", rename = "followRedirects")]
1878 pub follow_redirects: Option<bool>,
1879 #[serde(default, skip_serializing_if = "Option::is_none")]
1880 pub headers: Option<BTreeMap<String, String>>,
1881 #[serde(default, skip_serializing_if = "Option::is_none")]
1882 pub name: Option<String>,
1883 #[serde(default, skip_serializing_if = "Option::is_none")]
1884 pub oauth2: Option<PrometheusRemoteReadOauth2>,
1885 #[serde(default, skip_serializing_if = "Option::is_none", rename = "proxyUrl")]
1886 pub proxy_url: Option<String>,
1887 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readRecent")]
1888 pub read_recent: Option<bool>,
1889 #[serde(default, skip_serializing_if = "Option::is_none", rename = "remoteTimeout")]
1890 pub remote_timeout: Option<String>,
1891 #[serde(default, skip_serializing_if = "Option::is_none", rename = "requiredMatchers")]
1892 pub required_matchers: Option<BTreeMap<String, String>>,
1893 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
1894 pub tls_config: Option<PrometheusRemoteReadTlsConfig>,
1895 pub url: String,
1896}
1897
1898#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1899pub struct PrometheusRemoteReadAuthorization {
1900 #[serde(default, skip_serializing_if = "Option::is_none")]
1901 pub credentials: Option<PrometheusRemoteReadAuthorizationCredentials>,
1902 #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsFile")]
1903 pub credentials_file: Option<String>,
1904 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
1905 pub r#type: Option<String>,
1906}
1907
1908#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1909pub struct PrometheusRemoteReadAuthorizationCredentials {
1910 pub key: String,
1911 #[serde(default, skip_serializing_if = "Option::is_none")]
1912 pub name: Option<String>,
1913 #[serde(default, skip_serializing_if = "Option::is_none")]
1914 pub optional: Option<bool>,
1915}
1916
1917#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1918pub struct PrometheusRemoteReadBasicAuth {
1919 #[serde(default, skip_serializing_if = "Option::is_none")]
1920 pub password: Option<PrometheusRemoteReadBasicAuthPassword>,
1921 #[serde(default, skip_serializing_if = "Option::is_none")]
1922 pub username: Option<PrometheusRemoteReadBasicAuthUsername>,
1923}
1924
1925#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1926pub struct PrometheusRemoteReadBasicAuthPassword {
1927 pub key: String,
1928 #[serde(default, skip_serializing_if = "Option::is_none")]
1929 pub name: Option<String>,
1930 #[serde(default, skip_serializing_if = "Option::is_none")]
1931 pub optional: Option<bool>,
1932}
1933
1934#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1935pub struct PrometheusRemoteReadBasicAuthUsername {
1936 pub key: String,
1937 #[serde(default, skip_serializing_if = "Option::is_none")]
1938 pub name: Option<String>,
1939 #[serde(default, skip_serializing_if = "Option::is_none")]
1940 pub optional: Option<bool>,
1941}
1942
1943#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1944pub struct PrometheusRemoteReadOauth2 {
1945 #[serde(rename = "clientId")]
1946 pub client_id: PrometheusRemoteReadOauth2ClientId,
1947 #[serde(rename = "clientSecret")]
1948 pub client_secret: PrometheusRemoteReadOauth2ClientSecret,
1949 #[serde(default, skip_serializing_if = "Option::is_none", rename = "endpointParams")]
1950 pub endpoint_params: Option<BTreeMap<String, String>>,
1951 #[serde(default, skip_serializing_if = "Option::is_none")]
1952 pub scopes: Option<Vec<String>>,
1953 #[serde(rename = "tokenUrl")]
1954 pub token_url: String,
1955}
1956
1957#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1958pub struct PrometheusRemoteReadOauth2ClientId {
1959 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
1960 pub config_map: Option<PrometheusRemoteReadOauth2ClientIdConfigMap>,
1961 #[serde(default, skip_serializing_if = "Option::is_none")]
1962 pub secret: Option<PrometheusRemoteReadOauth2ClientIdSecret>,
1963}
1964
1965#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1966pub struct PrometheusRemoteReadOauth2ClientIdConfigMap {
1967 pub key: String,
1968 #[serde(default, skip_serializing_if = "Option::is_none")]
1969 pub name: Option<String>,
1970 #[serde(default, skip_serializing_if = "Option::is_none")]
1971 pub optional: Option<bool>,
1972}
1973
1974#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1975pub struct PrometheusRemoteReadOauth2ClientIdSecret {
1976 pub key: String,
1977 #[serde(default, skip_serializing_if = "Option::is_none")]
1978 pub name: Option<String>,
1979 #[serde(default, skip_serializing_if = "Option::is_none")]
1980 pub optional: Option<bool>,
1981}
1982
1983#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1984pub struct PrometheusRemoteReadOauth2ClientSecret {
1985 pub key: String,
1986 #[serde(default, skip_serializing_if = "Option::is_none")]
1987 pub name: Option<String>,
1988 #[serde(default, skip_serializing_if = "Option::is_none")]
1989 pub optional: Option<bool>,
1990}
1991
1992#[derive(Serialize, Deserialize, Clone, Debug, Default)]
1993pub struct PrometheusRemoteReadTlsConfig {
1994 #[serde(default, skip_serializing_if = "Option::is_none")]
1995 pub ca: Option<PrometheusRemoteReadTlsConfigCa>,
1996 #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
1997 pub ca_file: Option<String>,
1998 #[serde(default, skip_serializing_if = "Option::is_none")]
1999 pub cert: Option<PrometheusRemoteReadTlsConfigCert>,
2000 #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
2001 pub cert_file: Option<String>,
2002 #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
2003 pub insecure_skip_verify: Option<bool>,
2004 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
2005 pub key_file: Option<String>,
2006 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
2007 pub key_secret: Option<PrometheusRemoteReadTlsConfigKeySecret>,
2008 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
2009 pub server_name: Option<String>,
2010}
2011
2012#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2013pub struct PrometheusRemoteReadTlsConfigCa {
2014 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
2015 pub config_map: Option<PrometheusRemoteReadTlsConfigCaConfigMap>,
2016 #[serde(default, skip_serializing_if = "Option::is_none")]
2017 pub secret: Option<PrometheusRemoteReadTlsConfigCaSecret>,
2018}
2019
2020#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2021pub struct PrometheusRemoteReadTlsConfigCaConfigMap {
2022 pub key: String,
2023 #[serde(default, skip_serializing_if = "Option::is_none")]
2024 pub name: Option<String>,
2025 #[serde(default, skip_serializing_if = "Option::is_none")]
2026 pub optional: Option<bool>,
2027}
2028
2029#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2030pub struct PrometheusRemoteReadTlsConfigCaSecret {
2031 pub key: String,
2032 #[serde(default, skip_serializing_if = "Option::is_none")]
2033 pub name: Option<String>,
2034 #[serde(default, skip_serializing_if = "Option::is_none")]
2035 pub optional: Option<bool>,
2036}
2037
2038#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2039pub struct PrometheusRemoteReadTlsConfigCert {
2040 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
2041 pub config_map: Option<PrometheusRemoteReadTlsConfigCertConfigMap>,
2042 #[serde(default, skip_serializing_if = "Option::is_none")]
2043 pub secret: Option<PrometheusRemoteReadTlsConfigCertSecret>,
2044}
2045
2046#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2047pub struct PrometheusRemoteReadTlsConfigCertConfigMap {
2048 pub key: String,
2049 #[serde(default, skip_serializing_if = "Option::is_none")]
2050 pub name: Option<String>,
2051 #[serde(default, skip_serializing_if = "Option::is_none")]
2052 pub optional: Option<bool>,
2053}
2054
2055#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2056pub struct PrometheusRemoteReadTlsConfigCertSecret {
2057 pub key: String,
2058 #[serde(default, skip_serializing_if = "Option::is_none")]
2059 pub name: Option<String>,
2060 #[serde(default, skip_serializing_if = "Option::is_none")]
2061 pub optional: Option<bool>,
2062}
2063
2064#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2065pub struct PrometheusRemoteReadTlsConfigKeySecret {
2066 pub key: String,
2067 #[serde(default, skip_serializing_if = "Option::is_none")]
2068 pub name: Option<String>,
2069 #[serde(default, skip_serializing_if = "Option::is_none")]
2070 pub optional: Option<bool>,
2071}
2072
2073#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2074pub struct PrometheusRemoteWrite {
2075 #[serde(default, skip_serializing_if = "Option::is_none")]
2076 pub authorization: Option<PrometheusRemoteWriteAuthorization>,
2077 #[serde(default, skip_serializing_if = "Option::is_none", rename = "basicAuth")]
2078 pub basic_auth: Option<PrometheusRemoteWriteBasicAuth>,
2079 #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerToken")]
2080 pub bearer_token: Option<String>,
2081 #[serde(default, skip_serializing_if = "Option::is_none", rename = "bearerTokenFile")]
2082 pub bearer_token_file: Option<String>,
2083 #[serde(default, skip_serializing_if = "Option::is_none")]
2084 pub headers: Option<BTreeMap<String, String>>,
2085 #[serde(default, skip_serializing_if = "Option::is_none", rename = "metadataConfig")]
2086 pub metadata_config: Option<PrometheusRemoteWriteMetadataConfig>,
2087 #[serde(default, skip_serializing_if = "Option::is_none")]
2088 pub name: Option<String>,
2089 #[serde(default, skip_serializing_if = "Option::is_none")]
2090 pub oauth2: Option<PrometheusRemoteWriteOauth2>,
2091 #[serde(default, skip_serializing_if = "Option::is_none", rename = "proxyUrl")]
2092 pub proxy_url: Option<String>,
2093 #[serde(default, skip_serializing_if = "Option::is_none", rename = "queueConfig")]
2094 pub queue_config: Option<PrometheusRemoteWriteQueueConfig>,
2095 #[serde(default, skip_serializing_if = "Option::is_none", rename = "remoteTimeout")]
2096 pub remote_timeout: Option<String>,
2097 #[serde(default, skip_serializing_if = "Option::is_none", rename = "sendExemplars")]
2098 pub send_exemplars: Option<bool>,
2099 #[serde(default, skip_serializing_if = "Option::is_none", rename = "sendNativeHistograms")]
2100 pub send_native_histograms: Option<bool>,
2101 #[serde(default, skip_serializing_if = "Option::is_none")]
2102 pub sigv4: Option<PrometheusRemoteWriteSigv4>,
2103 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
2104 pub tls_config: Option<PrometheusRemoteWriteTlsConfig>,
2105 pub url: String,
2106 #[serde(default, skip_serializing_if = "Option::is_none", rename = "writeRelabelConfigs")]
2107 pub write_relabel_configs: Option<Vec<PrometheusRemoteWriteWriteRelabelConfigs>>,
2108}
2109
2110#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2111pub struct PrometheusRemoteWriteAuthorization {
2112 #[serde(default, skip_serializing_if = "Option::is_none")]
2113 pub credentials: Option<PrometheusRemoteWriteAuthorizationCredentials>,
2114 #[serde(default, skip_serializing_if = "Option::is_none", rename = "credentialsFile")]
2115 pub credentials_file: Option<String>,
2116 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
2117 pub r#type: Option<String>,
2118}
2119
2120#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2121pub struct PrometheusRemoteWriteAuthorizationCredentials {
2122 pub key: String,
2123 #[serde(default, skip_serializing_if = "Option::is_none")]
2124 pub name: Option<String>,
2125 #[serde(default, skip_serializing_if = "Option::is_none")]
2126 pub optional: Option<bool>,
2127}
2128
2129#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2130pub struct PrometheusRemoteWriteBasicAuth {
2131 #[serde(default, skip_serializing_if = "Option::is_none")]
2132 pub password: Option<PrometheusRemoteWriteBasicAuthPassword>,
2133 #[serde(default, skip_serializing_if = "Option::is_none")]
2134 pub username: Option<PrometheusRemoteWriteBasicAuthUsername>,
2135}
2136
2137#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2138pub struct PrometheusRemoteWriteBasicAuthPassword {
2139 pub key: String,
2140 #[serde(default, skip_serializing_if = "Option::is_none")]
2141 pub name: Option<String>,
2142 #[serde(default, skip_serializing_if = "Option::is_none")]
2143 pub optional: Option<bool>,
2144}
2145
2146#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2147pub struct PrometheusRemoteWriteBasicAuthUsername {
2148 pub key: String,
2149 #[serde(default, skip_serializing_if = "Option::is_none")]
2150 pub name: Option<String>,
2151 #[serde(default, skip_serializing_if = "Option::is_none")]
2152 pub optional: Option<bool>,
2153}
2154
2155#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2156pub struct PrometheusRemoteWriteMetadataConfig {
2157 #[serde(default, skip_serializing_if = "Option::is_none")]
2158 pub send: Option<bool>,
2159 #[serde(default, skip_serializing_if = "Option::is_none", rename = "sendInterval")]
2160 pub send_interval: Option<String>,
2161}
2162
2163#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2164pub struct PrometheusRemoteWriteOauth2 {
2165 #[serde(rename = "clientId")]
2166 pub client_id: PrometheusRemoteWriteOauth2ClientId,
2167 #[serde(rename = "clientSecret")]
2168 pub client_secret: PrometheusRemoteWriteOauth2ClientSecret,
2169 #[serde(default, skip_serializing_if = "Option::is_none", rename = "endpointParams")]
2170 pub endpoint_params: Option<BTreeMap<String, String>>,
2171 #[serde(default, skip_serializing_if = "Option::is_none")]
2172 pub scopes: Option<Vec<String>>,
2173 #[serde(rename = "tokenUrl")]
2174 pub token_url: String,
2175}
2176
2177#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2178pub struct PrometheusRemoteWriteOauth2ClientId {
2179 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
2180 pub config_map: Option<PrometheusRemoteWriteOauth2ClientIdConfigMap>,
2181 #[serde(default, skip_serializing_if = "Option::is_none")]
2182 pub secret: Option<PrometheusRemoteWriteOauth2ClientIdSecret>,
2183}
2184
2185#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2186pub struct PrometheusRemoteWriteOauth2ClientIdConfigMap {
2187 pub key: String,
2188 #[serde(default, skip_serializing_if = "Option::is_none")]
2189 pub name: Option<String>,
2190 #[serde(default, skip_serializing_if = "Option::is_none")]
2191 pub optional: Option<bool>,
2192}
2193
2194#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2195pub struct PrometheusRemoteWriteOauth2ClientIdSecret {
2196 pub key: String,
2197 #[serde(default, skip_serializing_if = "Option::is_none")]
2198 pub name: Option<String>,
2199 #[serde(default, skip_serializing_if = "Option::is_none")]
2200 pub optional: Option<bool>,
2201}
2202
2203#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2204pub struct PrometheusRemoteWriteOauth2ClientSecret {
2205 pub key: String,
2206 #[serde(default, skip_serializing_if = "Option::is_none")]
2207 pub name: Option<String>,
2208 #[serde(default, skip_serializing_if = "Option::is_none")]
2209 pub optional: Option<bool>,
2210}
2211
2212#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2213pub struct PrometheusRemoteWriteQueueConfig {
2214 #[serde(default, skip_serializing_if = "Option::is_none", rename = "batchSendDeadline")]
2215 pub batch_send_deadline: Option<String>,
2216 #[serde(default, skip_serializing_if = "Option::is_none")]
2217 pub capacity: Option<i64>,
2218 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxBackoff")]
2219 pub max_backoff: Option<String>,
2220 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxRetries")]
2221 pub max_retries: Option<i64>,
2222 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxSamplesPerSend")]
2223 pub max_samples_per_send: Option<i64>,
2224 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxShards")]
2225 pub max_shards: Option<i64>,
2226 #[serde(default, skip_serializing_if = "Option::is_none", rename = "minBackoff")]
2227 pub min_backoff: Option<String>,
2228 #[serde(default, skip_serializing_if = "Option::is_none", rename = "minShards")]
2229 pub min_shards: Option<i64>,
2230 #[serde(default, skip_serializing_if = "Option::is_none", rename = "retryOnRateLimit")]
2231 pub retry_on_rate_limit: Option<bool>,
2232}
2233
2234#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2235pub struct PrometheusRemoteWriteSigv4 {
2236 #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessKey")]
2237 pub access_key: Option<PrometheusRemoteWriteSigv4AccessKey>,
2238 #[serde(default, skip_serializing_if = "Option::is_none")]
2239 pub profile: Option<String>,
2240 #[serde(default, skip_serializing_if = "Option::is_none")]
2241 pub region: Option<String>,
2242 #[serde(default, skip_serializing_if = "Option::is_none", rename = "roleArn")]
2243 pub role_arn: Option<String>,
2244 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretKey")]
2245 pub secret_key: Option<PrometheusRemoteWriteSigv4SecretKey>,
2246}
2247
2248#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2249pub struct PrometheusRemoteWriteSigv4AccessKey {
2250 pub key: String,
2251 #[serde(default, skip_serializing_if = "Option::is_none")]
2252 pub name: Option<String>,
2253 #[serde(default, skip_serializing_if = "Option::is_none")]
2254 pub optional: Option<bool>,
2255}
2256
2257#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2258pub struct PrometheusRemoteWriteSigv4SecretKey {
2259 pub key: String,
2260 #[serde(default, skip_serializing_if = "Option::is_none")]
2261 pub name: Option<String>,
2262 #[serde(default, skip_serializing_if = "Option::is_none")]
2263 pub optional: Option<bool>,
2264}
2265
2266#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2267pub struct PrometheusRemoteWriteTlsConfig {
2268 #[serde(default, skip_serializing_if = "Option::is_none")]
2269 pub ca: Option<PrometheusRemoteWriteTlsConfigCa>,
2270 #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
2271 pub ca_file: Option<String>,
2272 #[serde(default, skip_serializing_if = "Option::is_none")]
2273 pub cert: Option<PrometheusRemoteWriteTlsConfigCert>,
2274 #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
2275 pub cert_file: Option<String>,
2276 #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
2277 pub insecure_skip_verify: Option<bool>,
2278 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
2279 pub key_file: Option<String>,
2280 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
2281 pub key_secret: Option<PrometheusRemoteWriteTlsConfigKeySecret>,
2282 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
2283 pub server_name: Option<String>,
2284}
2285
2286#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2287pub struct PrometheusRemoteWriteTlsConfigCa {
2288 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
2289 pub config_map: Option<PrometheusRemoteWriteTlsConfigCaConfigMap>,
2290 #[serde(default, skip_serializing_if = "Option::is_none")]
2291 pub secret: Option<PrometheusRemoteWriteTlsConfigCaSecret>,
2292}
2293
2294#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2295pub struct PrometheusRemoteWriteTlsConfigCaConfigMap {
2296 pub key: String,
2297 #[serde(default, skip_serializing_if = "Option::is_none")]
2298 pub name: Option<String>,
2299 #[serde(default, skip_serializing_if = "Option::is_none")]
2300 pub optional: Option<bool>,
2301}
2302
2303#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2304pub struct PrometheusRemoteWriteTlsConfigCaSecret {
2305 pub key: String,
2306 #[serde(default, skip_serializing_if = "Option::is_none")]
2307 pub name: Option<String>,
2308 #[serde(default, skip_serializing_if = "Option::is_none")]
2309 pub optional: Option<bool>,
2310}
2311
2312#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2313pub struct PrometheusRemoteWriteTlsConfigCert {
2314 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
2315 pub config_map: Option<PrometheusRemoteWriteTlsConfigCertConfigMap>,
2316 #[serde(default, skip_serializing_if = "Option::is_none")]
2317 pub secret: Option<PrometheusRemoteWriteTlsConfigCertSecret>,
2318}
2319
2320#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2321pub struct PrometheusRemoteWriteTlsConfigCertConfigMap {
2322 pub key: String,
2323 #[serde(default, skip_serializing_if = "Option::is_none")]
2324 pub name: Option<String>,
2325 #[serde(default, skip_serializing_if = "Option::is_none")]
2326 pub optional: Option<bool>,
2327}
2328
2329#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2330pub struct PrometheusRemoteWriteTlsConfigCertSecret {
2331 pub key: String,
2332 #[serde(default, skip_serializing_if = "Option::is_none")]
2333 pub name: Option<String>,
2334 #[serde(default, skip_serializing_if = "Option::is_none")]
2335 pub optional: Option<bool>,
2336}
2337
2338#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2339pub struct PrometheusRemoteWriteTlsConfigKeySecret {
2340 pub key: String,
2341 #[serde(default, skip_serializing_if = "Option::is_none")]
2342 pub name: Option<String>,
2343 #[serde(default, skip_serializing_if = "Option::is_none")]
2344 pub optional: Option<bool>,
2345}
2346
2347#[derive(Serialize, Deserialize, Clone, Debug, Default, JsonSchema)]
2348pub struct PrometheusRemoteWriteWriteRelabelConfigs {
2349 #[serde(default, skip_serializing_if = "Option::is_none")]
2350 pub action: Option<PrometheusRemoteWriteWriteRelabelConfigsAction>,
2351 #[serde(default, skip_serializing_if = "Option::is_none")]
2352 pub modulus: Option<i64>,
2353 #[serde(default, skip_serializing_if = "Option::is_none")]
2354 pub regex: Option<String>,
2355 #[serde(default, skip_serializing_if = "Option::is_none")]
2356 pub replacement: Option<String>,
2357 #[serde(default, skip_serializing_if = "Option::is_none")]
2358 pub separator: Option<String>,
2359 #[serde(default, skip_serializing_if = "Option::is_none", rename = "sourceLabels")]
2360 pub source_labels: Option<Vec<String>>,
2361 #[serde(default, skip_serializing_if = "Option::is_none", rename = "targetLabel")]
2362 pub target_label: Option<String>,
2363}
2364
2365#[derive(Serialize, Deserialize, Clone, Debug, JsonSchema)]
2366pub enum PrometheusRemoteWriteWriteRelabelConfigsAction {
2367 #[serde(rename = "replace")]
2368 Replace,
2369 #[serde(rename = "keep")]
2370 Keep,
2371 #[serde(rename = "drop")]
2372 Drop,
2373 #[serde(rename = "hashmod")]
2374 HashMod,
2375 #[serde(rename = "labelmap")]
2376 LabelMap,
2377 #[serde(rename = "labeldrop")]
2378 LabelDrop,
2379 #[serde(rename = "labelkeep")]
2380 LabelKeep,
2381 #[serde(rename = "lowercase")]
2382 Lowercase,
2383 #[serde(rename = "uppercase")]
2384 Uppercase,
2385 #[serde(rename = "keepequal")]
2386 KeepEqual,
2387 #[serde(rename = "dropequal")]
2388 DropEqual,
2389}
2390
2391#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2392pub struct PrometheusResources {
2393 #[serde(default, skip_serializing_if = "Option::is_none")]
2394 pub claims: Option<Vec<PrometheusResourcesClaims>>,
2395 #[serde(default, skip_serializing_if = "Option::is_none")]
2396 pub limits: Option<BTreeMap<String, IntOrString>>,
2397 #[serde(default, skip_serializing_if = "Option::is_none")]
2398 pub requests: Option<BTreeMap<String, IntOrString>>,
2399}
2400
2401#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2402pub struct PrometheusResourcesClaims {
2403 pub name: String,
2404}
2405
2406#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2407pub struct PrometheusRules {
2408 #[serde(default, skip_serializing_if = "Option::is_none")]
2409 pub alert: Option<PrometheusRulesAlert>,
2410}
2411
2412#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2413pub struct PrometheusRulesAlert {
2414 #[serde(default, skip_serializing_if = "Option::is_none", rename = "forGracePeriod")]
2415 pub for_grace_period: Option<String>,
2416 #[serde(default, skip_serializing_if = "Option::is_none", rename = "forOutageTolerance")]
2417 pub for_outage_tolerance: Option<String>,
2418 #[serde(default, skip_serializing_if = "Option::is_none", rename = "resendDelay")]
2419 pub resend_delay: Option<String>,
2420}
2421
2422#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2423pub struct PrometheusSecurityContext {
2424 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroup")]
2425 pub fs_group: Option<i64>,
2426 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsGroupChangePolicy")]
2427 pub fs_group_change_policy: Option<String>,
2428 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsGroup")]
2429 pub run_as_group: Option<i64>,
2430 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsNonRoot")]
2431 pub run_as_non_root: Option<bool>,
2432 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUser")]
2433 pub run_as_user: Option<i64>,
2434 #[serde(default, skip_serializing_if = "Option::is_none", rename = "seLinuxOptions")]
2435 pub se_linux_options: Option<PrometheusSecurityContextSeLinuxOptions>,
2436 #[serde(default, skip_serializing_if = "Option::is_none", rename = "seccompProfile")]
2437 pub seccomp_profile: Option<PrometheusSecurityContextSeccompProfile>,
2438 #[serde(default, skip_serializing_if = "Option::is_none", rename = "supplementalGroups")]
2439 pub supplemental_groups: Option<Vec<i64>>,
2440 #[serde(default, skip_serializing_if = "Option::is_none")]
2441 pub sysctls: Option<Vec<PrometheusSecurityContextSysctls>>,
2442 #[serde(default, skip_serializing_if = "Option::is_none", rename = "windowsOptions")]
2443 pub windows_options: Option<PrometheusSecurityContextWindowsOptions>,
2444}
2445
2446#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2447pub struct PrometheusSecurityContextSeLinuxOptions {
2448 #[serde(default, skip_serializing_if = "Option::is_none")]
2449 pub level: Option<String>,
2450 #[serde(default, skip_serializing_if = "Option::is_none")]
2451 pub role: Option<String>,
2452 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
2453 pub r#type: Option<String>,
2454 #[serde(default, skip_serializing_if = "Option::is_none")]
2455 pub user: Option<String>,
2456}
2457
2458#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2459pub struct PrometheusSecurityContextSeccompProfile {
2460 #[serde(default, skip_serializing_if = "Option::is_none", rename = "localhostProfile")]
2461 pub localhost_profile: Option<String>,
2462 #[serde(rename = "type")]
2463 pub r#type: String,
2464}
2465
2466#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2467pub struct PrometheusSecurityContextSysctls {
2468 pub name: String,
2469 pub value: String,
2470}
2471
2472#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2473pub struct PrometheusSecurityContextWindowsOptions {
2474 #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpec")]
2475 pub gmsa_credential_spec: Option<String>,
2476 #[serde(default, skip_serializing_if = "Option::is_none", rename = "gmsaCredentialSpecName")]
2477 pub gmsa_credential_spec_name: Option<String>,
2478 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostProcess")]
2479 pub host_process: Option<bool>,
2480 #[serde(default, skip_serializing_if = "Option::is_none", rename = "runAsUserName")]
2481 pub run_as_user_name: Option<String>,
2482}
2483
2484#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2485pub struct PrometheusStorage {
2486 #[serde(default, skip_serializing_if = "Option::is_none", rename = "disableMountSubPath")]
2487 pub disable_mount_sub_path: Option<bool>,
2488 #[serde(default, skip_serializing_if = "Option::is_none", rename = "emptyDir")]
2489 pub empty_dir: Option<PrometheusStorageEmptyDir>,
2490 #[serde(default, skip_serializing_if = "Option::is_none")]
2491 pub ephemeral: Option<PrometheusStorageEphemeral>,
2492 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeClaimTemplate")]
2493 pub volume_claim_template: Option<PrometheusStorageVolumeClaimTemplate>,
2494}
2495
2496#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2497pub struct PrometheusStorageEmptyDir {
2498 #[serde(default, skip_serializing_if = "Option::is_none")]
2499 pub medium: Option<String>,
2500 #[serde(default, skip_serializing_if = "Option::is_none", rename = "sizeLimit")]
2501 pub size_limit: Option<IntOrString>,
2502}
2503
2504#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2505pub struct PrometheusStorageEphemeral {
2506 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeClaimTemplate")]
2507 pub volume_claim_template: Option<PrometheusStorageEphemeralVolumeClaimTemplate>,
2508}
2509
2510#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2511pub struct PrometheusStorageEphemeralVolumeClaimTemplate {
2512 #[serde(default, skip_serializing_if = "Option::is_none")]
2513 pub metadata: Option<PrometheusStorageEphemeralVolumeClaimTemplateMetadata>,
2514 pub spec: PrometheusStorageEphemeralVolumeClaimTemplateSpec,
2515}
2516
2517#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2518pub struct PrometheusStorageEphemeralVolumeClaimTemplateMetadata {
2519}
2520
2521#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2522pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpec {
2523 #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessModes")]
2524 pub access_modes: Option<Vec<String>>,
2525 #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSource")]
2526 pub data_source: Option<PrometheusStorageEphemeralVolumeClaimTemplateSpecDataSource>,
2527 #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSourceRef")]
2528 pub data_source_ref: Option<PrometheusStorageEphemeralVolumeClaimTemplateSpecDataSourceRef>,
2529 #[serde(default, skip_serializing_if = "Option::is_none")]
2530 pub resources: Option<PrometheusStorageEphemeralVolumeClaimTemplateSpecResources>,
2531 #[serde(default, skip_serializing_if = "Option::is_none")]
2532 pub selector: Option<metav1::LabelSelector>,
2533 #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageClassName")]
2534 pub storage_class_name: Option<String>,
2535 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMode")]
2536 pub volume_mode: Option<String>,
2537 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
2538 pub volume_name: Option<String>,
2539}
2540
2541#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2542pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpecDataSource {
2543 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
2544 pub api_group: Option<String>,
2545 pub kind: String,
2546 pub name: String,
2547}
2548
2549#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2550pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpecDataSourceRef {
2551 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
2552 pub api_group: Option<String>,
2553 pub kind: String,
2554 pub name: String,
2555 #[serde(default, skip_serializing_if = "Option::is_none")]
2556 pub namespace: Option<String>,
2557}
2558
2559#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2560pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpecResources {
2561 #[serde(default, skip_serializing_if = "Option::is_none")]
2562 pub claims: Option<Vec<PrometheusStorageEphemeralVolumeClaimTemplateSpecResourcesClaims>>,
2563 #[serde(default, skip_serializing_if = "Option::is_none")]
2564 pub limits: Option<BTreeMap<String, IntOrString>>,
2565 #[serde(default, skip_serializing_if = "Option::is_none")]
2566 pub requests: Option<BTreeMap<String, IntOrString>>,
2567}
2568
2569#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2570pub struct PrometheusStorageEphemeralVolumeClaimTemplateSpecResourcesClaims {
2571 pub name: String,
2572}
2573
2574#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2575pub struct PrometheusStorageVolumeClaimTemplate {
2576 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
2577 pub api_version: Option<String>,
2578 #[serde(default, skip_serializing_if = "Option::is_none")]
2579 pub kind: Option<String>,
2580 #[serde(default, skip_serializing_if = "Option::is_none")]
2581 pub metadata: Option<PrometheusStorageVolumeClaimTemplateMetadata>,
2582 #[serde(default, skip_serializing_if = "Option::is_none")]
2583 pub spec: Option<PrometheusStorageVolumeClaimTemplateSpec>,
2584 #[serde(default, skip_serializing_if = "Option::is_none")]
2585 pub status: Option<PrometheusStorageVolumeClaimTemplateStatus>,
2586}
2587
2588#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2589pub struct PrometheusStorageVolumeClaimTemplateMetadata {
2590 #[serde(default, skip_serializing_if = "Option::is_none")]
2591 pub annotations: Option<BTreeMap<String, String>>,
2592 #[serde(default, skip_serializing_if = "Option::is_none")]
2593 pub labels: Option<BTreeMap<String, String>>,
2594 #[serde(default, skip_serializing_if = "Option::is_none")]
2595 pub name: Option<String>,
2596}
2597
2598#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2599pub struct PrometheusStorageVolumeClaimTemplateSpec {
2600 #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessModes")]
2601 pub access_modes: Option<Vec<String>>,
2602 #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSource")]
2603 pub data_source: Option<PrometheusStorageVolumeClaimTemplateSpecDataSource>,
2604 #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSourceRef")]
2605 pub data_source_ref: Option<PrometheusStorageVolumeClaimTemplateSpecDataSourceRef>,
2606 #[serde(default, skip_serializing_if = "Option::is_none")]
2607 pub resources: Option<PrometheusStorageVolumeClaimTemplateSpecResources>,
2608 #[serde(default, skip_serializing_if = "Option::is_none")]
2609 pub selector: Option<metav1::LabelSelector>,
2610 #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageClassName")]
2611 pub storage_class_name: Option<String>,
2612 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMode")]
2613 pub volume_mode: Option<String>,
2614 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
2615 pub volume_name: Option<String>,
2616}
2617
2618#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2619pub struct PrometheusStorageVolumeClaimTemplateSpecDataSource {
2620 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
2621 pub api_group: Option<String>,
2622 pub kind: String,
2623 pub name: String,
2624}
2625
2626#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2627pub struct PrometheusStorageVolumeClaimTemplateSpecDataSourceRef {
2628 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
2629 pub api_group: Option<String>,
2630 pub kind: String,
2631 pub name: String,
2632 #[serde(default, skip_serializing_if = "Option::is_none")]
2633 pub namespace: Option<String>,
2634}
2635
2636#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2637pub struct PrometheusStorageVolumeClaimTemplateSpecResources {
2638 #[serde(default, skip_serializing_if = "Option::is_none")]
2639 pub claims: Option<Vec<PrometheusStorageVolumeClaimTemplateSpecResourcesClaims>>,
2640 #[serde(default, skip_serializing_if = "Option::is_none")]
2641 pub limits: Option<BTreeMap<String, IntOrString>>,
2642 #[serde(default, skip_serializing_if = "Option::is_none")]
2643 pub requests: Option<BTreeMap<String, IntOrString>>,
2644}
2645
2646#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2647pub struct PrometheusStorageVolumeClaimTemplateSpecResourcesClaims {
2648 pub name: String,
2649}
2650
2651#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2652pub struct PrometheusStorageVolumeClaimTemplateStatus {
2653 #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessModes")]
2654 pub access_modes: Option<Vec<String>>,
2655 #[serde(default, skip_serializing_if = "Option::is_none", rename = "allocatedResources")]
2656 pub allocated_resources: Option<BTreeMap<String, IntOrString>>,
2657 #[serde(default, skip_serializing_if = "Option::is_none")]
2658 pub capacity: Option<BTreeMap<String, IntOrString>>,
2659 #[serde(default, skip_serializing_if = "Option::is_none")]
2660 pub conditions: Option<Vec<PrometheusStorageVolumeClaimTemplateStatusConditions>>,
2661 #[serde(default, skip_serializing_if = "Option::is_none")]
2662 pub phase: Option<String>,
2663 #[serde(default, skip_serializing_if = "Option::is_none", rename = "resizeStatus")]
2664 pub resize_status: Option<String>,
2665}
2666
2667#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2668pub struct PrometheusStorageVolumeClaimTemplateStatusConditions {
2669 #[serde(default, skip_serializing_if = "Option::is_none", rename = "lastProbeTime")]
2670 pub last_probe_time: Option<String>,
2671 #[serde(default, skip_serializing_if = "Option::is_none", rename = "lastTransitionTime")]
2672 pub last_transition_time: Option<String>,
2673 #[serde(default, skip_serializing_if = "Option::is_none")]
2674 pub message: Option<String>,
2675 #[serde(default, skip_serializing_if = "Option::is_none")]
2676 pub reason: Option<String>,
2677 pub status: String,
2678 #[serde(rename = "type")]
2679 pub r#type: String,
2680}
2681
2682#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2683pub struct PrometheusThanos {
2684 #[serde(default, skip_serializing_if = "Option::is_none", rename = "additionalArgs")]
2685 pub additional_args: Option<Vec<PrometheusThanosAdditionalArgs>>,
2686 #[serde(default, skip_serializing_if = "Option::is_none", rename = "baseImage")]
2687 pub base_image: Option<String>,
2688 #[serde(default, skip_serializing_if = "Option::is_none", rename = "blockSize")]
2689 pub block_size: Option<String>,
2690 #[serde(default, skip_serializing_if = "Option::is_none", rename = "getConfigInterval")]
2691 pub get_config_interval: Option<String>,
2692 #[serde(default, skip_serializing_if = "Option::is_none", rename = "getConfigTimeout")]
2693 pub get_config_timeout: Option<String>,
2694 #[serde(default, skip_serializing_if = "Option::is_none", rename = "grpcListenLocal")]
2695 pub grpc_listen_local: Option<bool>,
2696 #[serde(default, skip_serializing_if = "Option::is_none", rename = "grpcServerTlsConfig")]
2697 pub grpc_server_tls_config: Option<PrometheusThanosGrpcServerTlsConfig>,
2698 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpListenLocal")]
2699 pub http_listen_local: Option<bool>,
2700 #[serde(default, skip_serializing_if = "Option::is_none")]
2701 pub image: Option<String>,
2702 #[serde(default, skip_serializing_if = "Option::is_none", rename = "listenLocal")]
2703 pub listen_local: Option<bool>,
2704 #[serde(default, skip_serializing_if = "Option::is_none", rename = "logFormat")]
2705 pub log_format: Option<PrometheusThanosLogFormat>,
2706 #[serde(default, skip_serializing_if = "Option::is_none", rename = "logLevel")]
2707 pub log_level: Option<PrometheusThanosLogLevel>,
2708 #[serde(default, skip_serializing_if = "Option::is_none", rename = "minTime")]
2709 pub min_time: Option<String>,
2710 #[serde(default, skip_serializing_if = "Option::is_none", rename = "objectStorageConfig")]
2711 pub object_storage_config: Option<PrometheusThanosObjectStorageConfig>,
2712 #[serde(default, skip_serializing_if = "Option::is_none", rename = "objectStorageConfigFile")]
2713 pub object_storage_config_file: Option<String>,
2714 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readyTimeout")]
2715 pub ready_timeout: Option<String>,
2716 #[serde(default, skip_serializing_if = "Option::is_none")]
2717 pub resources: Option<PrometheusThanosResources>,
2718 #[serde(default, skip_serializing_if = "Option::is_none")]
2719 pub sha: Option<String>,
2720 #[serde(default, skip_serializing_if = "Option::is_none")]
2721 pub tag: Option<String>,
2722 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tracingConfig")]
2723 pub tracing_config: Option<PrometheusThanosTracingConfig>,
2724 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tracingConfigFile")]
2725 pub tracing_config_file: Option<String>,
2726 #[serde(default, skip_serializing_if = "Option::is_none")]
2727 pub version: Option<String>,
2728 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMounts")]
2729 pub volume_mounts: Option<Vec<PrometheusThanosVolumeMounts>>,
2730}
2731
2732#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2733pub struct PrometheusThanosAdditionalArgs {
2734 pub name: String,
2735 #[serde(default, skip_serializing_if = "Option::is_none")]
2736 pub value: Option<String>,
2737}
2738
2739#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2740pub struct PrometheusThanosGrpcServerTlsConfig {
2741 #[serde(default, skip_serializing_if = "Option::is_none")]
2742 pub ca: Option<PrometheusThanosGrpcServerTlsConfigCa>,
2743 #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
2744 pub ca_file: Option<String>,
2745 #[serde(default, skip_serializing_if = "Option::is_none")]
2746 pub cert: Option<PrometheusThanosGrpcServerTlsConfigCert>,
2747 #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
2748 pub cert_file: Option<String>,
2749 #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
2750 pub insecure_skip_verify: Option<bool>,
2751 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
2752 pub key_file: Option<String>,
2753 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
2754 pub key_secret: Option<PrometheusThanosGrpcServerTlsConfigKeySecret>,
2755 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
2756 pub server_name: Option<String>,
2757}
2758
2759#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2760pub struct PrometheusThanosGrpcServerTlsConfigCa {
2761 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
2762 pub config_map: Option<PrometheusThanosGrpcServerTlsConfigCaConfigMap>,
2763 #[serde(default, skip_serializing_if = "Option::is_none")]
2764 pub secret: Option<PrometheusThanosGrpcServerTlsConfigCaSecret>,
2765}
2766
2767#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2768pub struct PrometheusThanosGrpcServerTlsConfigCaConfigMap {
2769 pub key: String,
2770 #[serde(default, skip_serializing_if = "Option::is_none")]
2771 pub name: Option<String>,
2772 #[serde(default, skip_serializing_if = "Option::is_none")]
2773 pub optional: Option<bool>,
2774}
2775
2776#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2777pub struct PrometheusThanosGrpcServerTlsConfigCaSecret {
2778 pub key: String,
2779 #[serde(default, skip_serializing_if = "Option::is_none")]
2780 pub name: Option<String>,
2781 #[serde(default, skip_serializing_if = "Option::is_none")]
2782 pub optional: Option<bool>,
2783}
2784
2785#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2786pub struct PrometheusThanosGrpcServerTlsConfigCert {
2787 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
2788 pub config_map: Option<PrometheusThanosGrpcServerTlsConfigCertConfigMap>,
2789 #[serde(default, skip_serializing_if = "Option::is_none")]
2790 pub secret: Option<PrometheusThanosGrpcServerTlsConfigCertSecret>,
2791}
2792
2793#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2794pub struct PrometheusThanosGrpcServerTlsConfigCertConfigMap {
2795 pub key: String,
2796 #[serde(default, skip_serializing_if = "Option::is_none")]
2797 pub name: Option<String>,
2798 #[serde(default, skip_serializing_if = "Option::is_none")]
2799 pub optional: Option<bool>,
2800}
2801
2802#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2803pub struct PrometheusThanosGrpcServerTlsConfigCertSecret {
2804 pub key: String,
2805 #[serde(default, skip_serializing_if = "Option::is_none")]
2806 pub name: Option<String>,
2807 #[serde(default, skip_serializing_if = "Option::is_none")]
2808 pub optional: Option<bool>,
2809}
2810
2811#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2812pub struct PrometheusThanosGrpcServerTlsConfigKeySecret {
2813 pub key: String,
2814 #[serde(default, skip_serializing_if = "Option::is_none")]
2815 pub name: Option<String>,
2816 #[serde(default, skip_serializing_if = "Option::is_none")]
2817 pub optional: Option<bool>,
2818}
2819
2820#[derive(Serialize, Deserialize, Clone, Debug)]
2821pub enum PrometheusThanosLogFormat {
2822 #[serde(rename = "")]
2823 KopiumEmpty,
2824 #[serde(rename = "logfmt")]
2825 Logfmt,
2826 #[serde(rename = "json")]
2827 Json,
2828}
2829
2830#[derive(Serialize, Deserialize, Clone, Debug)]
2831pub enum PrometheusThanosLogLevel {
2832 #[serde(rename = "")]
2833 KopiumEmpty,
2834 #[serde(rename = "debug")]
2835 Debug,
2836 #[serde(rename = "info")]
2837 Info,
2838 #[serde(rename = "warn")]
2839 Warn,
2840 #[serde(rename = "error")]
2841 Error,
2842}
2843
2844#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2845pub struct PrometheusThanosObjectStorageConfig {
2846 pub key: String,
2847 #[serde(default, skip_serializing_if = "Option::is_none")]
2848 pub name: Option<String>,
2849 #[serde(default, skip_serializing_if = "Option::is_none")]
2850 pub optional: Option<bool>,
2851}
2852
2853#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2854pub struct PrometheusThanosResources {
2855 #[serde(default, skip_serializing_if = "Option::is_none")]
2856 pub claims: Option<Vec<PrometheusThanosResourcesClaims>>,
2857 #[serde(default, skip_serializing_if = "Option::is_none")]
2858 pub limits: Option<BTreeMap<String, IntOrString>>,
2859 #[serde(default, skip_serializing_if = "Option::is_none")]
2860 pub requests: Option<BTreeMap<String, IntOrString>>,
2861}
2862
2863#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2864pub struct PrometheusThanosResourcesClaims {
2865 pub name: String,
2866}
2867
2868#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2869pub struct PrometheusThanosTracingConfig {
2870 pub key: String,
2871 #[serde(default, skip_serializing_if = "Option::is_none")]
2872 pub name: Option<String>,
2873 #[serde(default, skip_serializing_if = "Option::is_none")]
2874 pub optional: Option<bool>,
2875}
2876
2877#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2878pub struct PrometheusThanosVolumeMounts {
2879 #[serde(rename = "mountPath")]
2880 pub mount_path: String,
2881 #[serde(default, skip_serializing_if = "Option::is_none", rename = "mountPropagation")]
2882 pub mount_propagation: Option<String>,
2883 pub name: String,
2884 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
2885 pub read_only: Option<bool>,
2886 #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPath")]
2887 pub sub_path: Option<String>,
2888 #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPathExpr")]
2889 pub sub_path_expr: Option<String>,
2890}
2891
2892#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2893pub struct PrometheusTolerations {
2894 #[serde(default, skip_serializing_if = "Option::is_none")]
2895 pub effect: Option<String>,
2896 #[serde(default, skip_serializing_if = "Option::is_none")]
2897 pub key: Option<String>,
2898 #[serde(default, skip_serializing_if = "Option::is_none")]
2899 pub operator: Option<String>,
2900 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tolerationSeconds")]
2901 pub toleration_seconds: Option<i64>,
2902 #[serde(default, skip_serializing_if = "Option::is_none")]
2903 pub value: Option<String>,
2904}
2905
2906#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2907pub struct PrometheusTopologySpreadConstraints {
2908 #[serde(default, skip_serializing_if = "Option::is_none", rename = "labelSelector")]
2909 pub label_selector: Option<metav1::LabelSelector>,
2910 #[serde(default, skip_serializing_if = "Option::is_none", rename = "matchLabelKeys")]
2911 pub match_label_keys: Option<Vec<String>>,
2912 #[serde(rename = "maxSkew")]
2913 pub max_skew: i32,
2914 #[serde(default, skip_serializing_if = "Option::is_none", rename = "minDomains")]
2915 pub min_domains: Option<i32>,
2916 #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeAffinityPolicy")]
2917 pub node_affinity_policy: Option<String>,
2918 #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodeTaintsPolicy")]
2919 pub node_taints_policy: Option<String>,
2920 #[serde(rename = "topologyKey")]
2921 pub topology_key: String,
2922 #[serde(rename = "whenUnsatisfiable")]
2923 pub when_unsatisfiable: String,
2924}
2925
2926#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2927pub struct PrometheusTracingConfig {
2928 #[serde(default, skip_serializing_if = "Option::is_none", rename = "clientType")]
2929 pub client_type: Option<PrometheusTracingConfigClientType>,
2930 #[serde(default, skip_serializing_if = "Option::is_none")]
2931 pub compression: Option<PrometheusTracingConfigCompression>,
2932 pub endpoint: String,
2933 #[serde(default, skip_serializing_if = "Option::is_none")]
2934 pub headers: Option<BTreeMap<String, String>>,
2935 #[serde(default, skip_serializing_if = "Option::is_none")]
2936 pub insecure: Option<bool>,
2937 #[serde(default, skip_serializing_if = "Option::is_none", rename = "samplingFraction")]
2938 pub sampling_fraction: Option<IntOrString>,
2939 #[serde(default, skip_serializing_if = "Option::is_none")]
2940 pub timeout: Option<String>,
2941 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
2942 pub tls_config: Option<PrometheusTracingConfigTlsConfig>,
2943}
2944
2945#[derive(Serialize, Deserialize, Clone, Debug)]
2946pub enum PrometheusTracingConfigClientType {
2947 #[serde(rename = "http")]
2948 Http,
2949 #[serde(rename = "grpc")]
2950 Grpc,
2951}
2952
2953#[derive(Serialize, Deserialize, Clone, Debug)]
2954pub enum PrometheusTracingConfigCompression {
2955 #[serde(rename = "gzip")]
2956 Gzip,
2957}
2958
2959#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2960pub struct PrometheusTracingConfigTlsConfig {
2961 #[serde(default, skip_serializing_if = "Option::is_none")]
2962 pub ca: Option<PrometheusTracingConfigTlsConfigCa>,
2963 #[serde(default, skip_serializing_if = "Option::is_none", rename = "caFile")]
2964 pub ca_file: Option<String>,
2965 #[serde(default, skip_serializing_if = "Option::is_none")]
2966 pub cert: Option<PrometheusTracingConfigTlsConfigCert>,
2967 #[serde(default, skip_serializing_if = "Option::is_none", rename = "certFile")]
2968 pub cert_file: Option<String>,
2969 #[serde(default, skip_serializing_if = "Option::is_none", rename = "insecureSkipVerify")]
2970 pub insecure_skip_verify: Option<bool>,
2971 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keyFile")]
2972 pub key_file: Option<String>,
2973 #[serde(default, skip_serializing_if = "Option::is_none", rename = "keySecret")]
2974 pub key_secret: Option<PrometheusTracingConfigTlsConfigKeySecret>,
2975 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serverName")]
2976 pub server_name: Option<String>,
2977}
2978
2979#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2980pub struct PrometheusTracingConfigTlsConfigCa {
2981 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
2982 pub config_map: Option<PrometheusTracingConfigTlsConfigCaConfigMap>,
2983 #[serde(default, skip_serializing_if = "Option::is_none")]
2984 pub secret: Option<PrometheusTracingConfigTlsConfigCaSecret>,
2985}
2986
2987#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2988pub struct PrometheusTracingConfigTlsConfigCaConfigMap {
2989 pub key: String,
2990 #[serde(default, skip_serializing_if = "Option::is_none")]
2991 pub name: Option<String>,
2992 #[serde(default, skip_serializing_if = "Option::is_none")]
2993 pub optional: Option<bool>,
2994}
2995
2996#[derive(Serialize, Deserialize, Clone, Debug, Default)]
2997pub struct PrometheusTracingConfigTlsConfigCaSecret {
2998 pub key: String,
2999 #[serde(default, skip_serializing_if = "Option::is_none")]
3000 pub name: Option<String>,
3001 #[serde(default, skip_serializing_if = "Option::is_none")]
3002 pub optional: Option<bool>,
3003}
3004
3005#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3006pub struct PrometheusTracingConfigTlsConfigCert {
3007 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
3008 pub config_map: Option<PrometheusTracingConfigTlsConfigCertConfigMap>,
3009 #[serde(default, skip_serializing_if = "Option::is_none")]
3010 pub secret: Option<PrometheusTracingConfigTlsConfigCertSecret>,
3011}
3012
3013#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3014pub struct PrometheusTracingConfigTlsConfigCertConfigMap {
3015 pub key: String,
3016 #[serde(default, skip_serializing_if = "Option::is_none")]
3017 pub name: Option<String>,
3018 #[serde(default, skip_serializing_if = "Option::is_none")]
3019 pub optional: Option<bool>,
3020}
3021
3022#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3023pub struct PrometheusTracingConfigTlsConfigCertSecret {
3024 pub key: String,
3025 #[serde(default, skip_serializing_if = "Option::is_none")]
3026 pub name: Option<String>,
3027 #[serde(default, skip_serializing_if = "Option::is_none")]
3028 pub optional: Option<bool>,
3029}
3030
3031#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3032pub struct PrometheusTracingConfigTlsConfigKeySecret {
3033 pub key: String,
3034 #[serde(default, skip_serializing_if = "Option::is_none")]
3035 pub name: Option<String>,
3036 #[serde(default, skip_serializing_if = "Option::is_none")]
3037 pub optional: Option<bool>,
3038}
3039
3040#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3041pub struct PrometheusTsdb {
3042 #[serde(default, skip_serializing_if = "Option::is_none", rename = "outOfOrderTimeWindow")]
3043 pub out_of_order_time_window: Option<String>,
3044}
3045
3046#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3047pub struct PrometheusVolumeMounts {
3048 #[serde(rename = "mountPath")]
3049 pub mount_path: String,
3050 #[serde(default, skip_serializing_if = "Option::is_none", rename = "mountPropagation")]
3051 pub mount_propagation: Option<String>,
3052 pub name: String,
3053 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3054 pub read_only: Option<bool>,
3055 #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPath")]
3056 pub sub_path: Option<String>,
3057 #[serde(default, skip_serializing_if = "Option::is_none", rename = "subPathExpr")]
3058 pub sub_path_expr: Option<String>,
3059}
3060
3061#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3062pub struct PrometheusVolumes {
3063 #[serde(default, skip_serializing_if = "Option::is_none", rename = "awsElasticBlockStore")]
3064 pub aws_elastic_block_store: Option<PrometheusVolumesAwsElasticBlockStore>,
3065 #[serde(default, skip_serializing_if = "Option::is_none", rename = "azureDisk")]
3066 pub azure_disk: Option<PrometheusVolumesAzureDisk>,
3067 #[serde(default, skip_serializing_if = "Option::is_none", rename = "azureFile")]
3068 pub azure_file: Option<PrometheusVolumesAzureFile>,
3069 #[serde(default, skip_serializing_if = "Option::is_none")]
3070 pub cephfs: Option<PrometheusVolumesCephfs>,
3071 #[serde(default, skip_serializing_if = "Option::is_none")]
3072 pub cinder: Option<PrometheusVolumesCinder>,
3073 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
3074 pub config_map: Option<PrometheusVolumesConfigMap>,
3075 #[serde(default, skip_serializing_if = "Option::is_none")]
3076 pub csi: Option<PrometheusVolumesCsi>,
3077 #[serde(default, skip_serializing_if = "Option::is_none", rename = "downwardAPI")]
3078 pub downward_api: Option<PrometheusVolumesDownwardApi>,
3079 #[serde(default, skip_serializing_if = "Option::is_none", rename = "emptyDir")]
3080 pub empty_dir: Option<PrometheusVolumesEmptyDir>,
3081 #[serde(default, skip_serializing_if = "Option::is_none")]
3082 pub ephemeral: Option<PrometheusVolumesEphemeral>,
3083 #[serde(default, skip_serializing_if = "Option::is_none")]
3084 pub fc: Option<PrometheusVolumesFc>,
3085 #[serde(default, skip_serializing_if = "Option::is_none", rename = "flexVolume")]
3086 pub flex_volume: Option<PrometheusVolumesFlexVolume>,
3087 #[serde(default, skip_serializing_if = "Option::is_none")]
3088 pub flocker: Option<PrometheusVolumesFlocker>,
3089 #[serde(default, skip_serializing_if = "Option::is_none", rename = "gcePersistentDisk")]
3090 pub gce_persistent_disk: Option<PrometheusVolumesGcePersistentDisk>,
3091 #[serde(default, skip_serializing_if = "Option::is_none", rename = "gitRepo")]
3092 pub git_repo: Option<PrometheusVolumesGitRepo>,
3093 #[serde(default, skip_serializing_if = "Option::is_none")]
3094 pub glusterfs: Option<PrometheusVolumesGlusterfs>,
3095 #[serde(default, skip_serializing_if = "Option::is_none", rename = "hostPath")]
3096 pub host_path: Option<PrometheusVolumesHostPath>,
3097 #[serde(default, skip_serializing_if = "Option::is_none")]
3098 pub iscsi: Option<PrometheusVolumesIscsi>,
3099 pub name: String,
3100 #[serde(default, skip_serializing_if = "Option::is_none")]
3101 pub nfs: Option<PrometheusVolumesNfs>,
3102 #[serde(default, skip_serializing_if = "Option::is_none", rename = "persistentVolumeClaim")]
3103 pub persistent_volume_claim: Option<PrometheusVolumesPersistentVolumeClaim>,
3104 #[serde(default, skip_serializing_if = "Option::is_none", rename = "photonPersistentDisk")]
3105 pub photon_persistent_disk: Option<PrometheusVolumesPhotonPersistentDisk>,
3106 #[serde(default, skip_serializing_if = "Option::is_none", rename = "portworxVolume")]
3107 pub portworx_volume: Option<PrometheusVolumesPortworxVolume>,
3108 #[serde(default, skip_serializing_if = "Option::is_none")]
3109 pub projected: Option<PrometheusVolumesProjected>,
3110 #[serde(default, skip_serializing_if = "Option::is_none")]
3111 pub quobyte: Option<PrometheusVolumesQuobyte>,
3112 #[serde(default, skip_serializing_if = "Option::is_none")]
3113 pub rbd: Option<PrometheusVolumesRbd>,
3114 #[serde(default, skip_serializing_if = "Option::is_none", rename = "scaleIO")]
3115 pub scale_io: Option<PrometheusVolumesScaleIo>,
3116 #[serde(default, skip_serializing_if = "Option::is_none")]
3117 pub secret: Option<PrometheusVolumesSecret>,
3118 #[serde(default, skip_serializing_if = "Option::is_none")]
3119 pub storageos: Option<PrometheusVolumesStorageos>,
3120 #[serde(default, skip_serializing_if = "Option::is_none", rename = "vsphereVolume")]
3121 pub vsphere_volume: Option<PrometheusVolumesVsphereVolume>,
3122}
3123
3124#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3125pub struct PrometheusVolumesAwsElasticBlockStore {
3126 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3127 pub fs_type: Option<String>,
3128 #[serde(default, skip_serializing_if = "Option::is_none")]
3129 pub partition: Option<i32>,
3130 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3131 pub read_only: Option<bool>,
3132 #[serde(rename = "volumeID")]
3133 pub volume_id: String,
3134}
3135
3136#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3137pub struct PrometheusVolumesAzureDisk {
3138 #[serde(default, skip_serializing_if = "Option::is_none", rename = "cachingMode")]
3139 pub caching_mode: Option<String>,
3140 #[serde(rename = "diskName")]
3141 pub disk_name: String,
3142 #[serde(rename = "diskURI")]
3143 pub disk_uri: String,
3144 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3145 pub fs_type: Option<String>,
3146 #[serde(default, skip_serializing_if = "Option::is_none")]
3147 pub kind: Option<String>,
3148 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3149 pub read_only: Option<bool>,
3150}
3151
3152#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3153pub struct PrometheusVolumesAzureFile {
3154 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3155 pub read_only: Option<bool>,
3156 #[serde(rename = "secretName")]
3157 pub secret_name: String,
3158 #[serde(rename = "shareName")]
3159 pub share_name: String,
3160}
3161
3162#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3163pub struct PrometheusVolumesCephfs {
3164 pub monitors: Vec<String>,
3165 #[serde(default, skip_serializing_if = "Option::is_none")]
3166 pub path: Option<String>,
3167 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3168 pub read_only: Option<bool>,
3169 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretFile")]
3170 pub secret_file: Option<String>,
3171 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
3172 pub secret_ref: Option<PrometheusVolumesCephfsSecretRef>,
3173 #[serde(default, skip_serializing_if = "Option::is_none")]
3174 pub user: Option<String>,
3175}
3176
3177#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3178pub struct PrometheusVolumesCephfsSecretRef {
3179 #[serde(default, skip_serializing_if = "Option::is_none")]
3180 pub name: Option<String>,
3181}
3182
3183#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3184pub struct PrometheusVolumesCinder {
3185 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3186 pub fs_type: Option<String>,
3187 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3188 pub read_only: Option<bool>,
3189 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
3190 pub secret_ref: Option<PrometheusVolumesCinderSecretRef>,
3191 #[serde(rename = "volumeID")]
3192 pub volume_id: String,
3193}
3194
3195#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3196pub struct PrometheusVolumesCinderSecretRef {
3197 #[serde(default, skip_serializing_if = "Option::is_none")]
3198 pub name: Option<String>,
3199}
3200
3201#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3202pub struct PrometheusVolumesConfigMap {
3203 #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
3204 pub default_mode: Option<i32>,
3205 #[serde(default, skip_serializing_if = "Option::is_none")]
3206 pub items: Option<Vec<PrometheusVolumesConfigMapItems>>,
3207 #[serde(default, skip_serializing_if = "Option::is_none")]
3208 pub name: Option<String>,
3209 #[serde(default, skip_serializing_if = "Option::is_none")]
3210 pub optional: Option<bool>,
3211}
3212
3213#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3214pub struct PrometheusVolumesConfigMapItems {
3215 pub key: String,
3216 #[serde(default, skip_serializing_if = "Option::is_none")]
3217 pub mode: Option<i32>,
3218 pub path: String,
3219}
3220
3221#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3222pub struct PrometheusVolumesCsi {
3223 pub driver: String,
3224 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3225 pub fs_type: Option<String>,
3226 #[serde(default, skip_serializing_if = "Option::is_none", rename = "nodePublishSecretRef")]
3227 pub node_publish_secret_ref: Option<PrometheusVolumesCsiNodePublishSecretRef>,
3228 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3229 pub read_only: Option<bool>,
3230 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeAttributes")]
3231 pub volume_attributes: Option<BTreeMap<String, String>>,
3232}
3233
3234#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3235pub struct PrometheusVolumesCsiNodePublishSecretRef {
3236 #[serde(default, skip_serializing_if = "Option::is_none")]
3237 pub name: Option<String>,
3238}
3239
3240#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3241pub struct PrometheusVolumesDownwardApi {
3242 #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
3243 pub default_mode: Option<i32>,
3244 #[serde(default, skip_serializing_if = "Option::is_none")]
3245 pub items: Option<Vec<PrometheusVolumesDownwardApiItems>>,
3246}
3247
3248#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3249pub struct PrometheusVolumesDownwardApiItems {
3250 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
3251 pub field_ref: Option<PrometheusVolumesDownwardApiItemsFieldRef>,
3252 #[serde(default, skip_serializing_if = "Option::is_none")]
3253 pub mode: Option<i32>,
3254 pub path: String,
3255 #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
3256 pub resource_field_ref: Option<PrometheusVolumesDownwardApiItemsResourceFieldRef>,
3257}
3258
3259#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3260pub struct PrometheusVolumesDownwardApiItemsFieldRef {
3261 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
3262 pub api_version: Option<String>,
3263 #[serde(rename = "fieldPath")]
3264 pub field_path: String,
3265}
3266
3267#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3268pub struct PrometheusVolumesDownwardApiItemsResourceFieldRef {
3269 #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
3270 pub container_name: Option<String>,
3271 #[serde(default, skip_serializing_if = "Option::is_none")]
3272 pub divisor: Option<IntOrString>,
3273 pub resource: String,
3274}
3275
3276#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3277pub struct PrometheusVolumesEmptyDir {
3278 #[serde(default, skip_serializing_if = "Option::is_none")]
3279 pub medium: Option<String>,
3280 #[serde(default, skip_serializing_if = "Option::is_none", rename = "sizeLimit")]
3281 pub size_limit: Option<IntOrString>,
3282}
3283
3284#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3285pub struct PrometheusVolumesEphemeral {
3286 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeClaimTemplate")]
3287 pub volume_claim_template: Option<PrometheusVolumesEphemeralVolumeClaimTemplate>,
3288}
3289
3290#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3291pub struct PrometheusVolumesEphemeralVolumeClaimTemplate {
3292 #[serde(default, skip_serializing_if = "Option::is_none")]
3293 pub metadata: Option<PrometheusVolumesEphemeralVolumeClaimTemplateMetadata>,
3294 pub spec: PrometheusVolumesEphemeralVolumeClaimTemplateSpec,
3295}
3296
3297#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3298pub struct PrometheusVolumesEphemeralVolumeClaimTemplateMetadata {
3299}
3300
3301#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3302pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpec {
3303 #[serde(default, skip_serializing_if = "Option::is_none", rename = "accessModes")]
3304 pub access_modes: Option<Vec<String>>,
3305 #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSource")]
3306 pub data_source: Option<PrometheusVolumesEphemeralVolumeClaimTemplateSpecDataSource>,
3307 #[serde(default, skip_serializing_if = "Option::is_none", rename = "dataSourceRef")]
3308 pub data_source_ref: Option<PrometheusVolumesEphemeralVolumeClaimTemplateSpecDataSourceRef>,
3309 #[serde(default, skip_serializing_if = "Option::is_none")]
3310 pub resources: Option<PrometheusVolumesEphemeralVolumeClaimTemplateSpecResources>,
3311 #[serde(default, skip_serializing_if = "Option::is_none")]
3312 pub selector: Option<metav1::LabelSelector>,
3313 #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageClassName")]
3314 pub storage_class_name: Option<String>,
3315 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeMode")]
3316 pub volume_mode: Option<String>,
3317 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
3318 pub volume_name: Option<String>,
3319}
3320
3321#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3322pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpecDataSource {
3323 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
3324 pub api_group: Option<String>,
3325 pub kind: String,
3326 pub name: String,
3327}
3328
3329#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3330pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpecDataSourceRef {
3331 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiGroup")]
3332 pub api_group: Option<String>,
3333 pub kind: String,
3334 pub name: String,
3335 #[serde(default, skip_serializing_if = "Option::is_none")]
3336 pub namespace: Option<String>,
3337}
3338
3339#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3340pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpecResources {
3341 #[serde(default, skip_serializing_if = "Option::is_none")]
3342 pub claims: Option<Vec<PrometheusVolumesEphemeralVolumeClaimTemplateSpecResourcesClaims>>,
3343 #[serde(default, skip_serializing_if = "Option::is_none")]
3344 pub limits: Option<BTreeMap<String, IntOrString>>,
3345 #[serde(default, skip_serializing_if = "Option::is_none")]
3346 pub requests: Option<BTreeMap<String, IntOrString>>,
3347}
3348
3349#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3350pub struct PrometheusVolumesEphemeralVolumeClaimTemplateSpecResourcesClaims {
3351 pub name: String,
3352}
3353
3354#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3355pub struct PrometheusVolumesFc {
3356 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3357 pub fs_type: Option<String>,
3358 #[serde(default, skip_serializing_if = "Option::is_none")]
3359 pub lun: Option<i32>,
3360 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3361 pub read_only: Option<bool>,
3362 #[serde(default, skip_serializing_if = "Option::is_none", rename = "targetWWNs")]
3363 pub target_ww_ns: Option<Vec<String>>,
3364 #[serde(default, skip_serializing_if = "Option::is_none")]
3365 pub wwids: Option<Vec<String>>,
3366}
3367
3368#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3369pub struct PrometheusVolumesFlexVolume {
3370 pub driver: String,
3371 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3372 pub fs_type: Option<String>,
3373 #[serde(default, skip_serializing_if = "Option::is_none")]
3374 pub options: Option<BTreeMap<String, String>>,
3375 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3376 pub read_only: Option<bool>,
3377 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
3378 pub secret_ref: Option<PrometheusVolumesFlexVolumeSecretRef>,
3379}
3380
3381#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3382pub struct PrometheusVolumesFlexVolumeSecretRef {
3383 #[serde(default, skip_serializing_if = "Option::is_none")]
3384 pub name: Option<String>,
3385}
3386
3387#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3388pub struct PrometheusVolumesFlocker {
3389 #[serde(default, skip_serializing_if = "Option::is_none", rename = "datasetName")]
3390 pub dataset_name: Option<String>,
3391 #[serde(default, skip_serializing_if = "Option::is_none", rename = "datasetUUID")]
3392 pub dataset_uuid: Option<String>,
3393}
3394
3395#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3396pub struct PrometheusVolumesGcePersistentDisk {
3397 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3398 pub fs_type: Option<String>,
3399 #[serde(default, skip_serializing_if = "Option::is_none")]
3400 pub partition: Option<i32>,
3401 #[serde(rename = "pdName")]
3402 pub pd_name: String,
3403 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3404 pub read_only: Option<bool>,
3405}
3406
3407#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3408pub struct PrometheusVolumesGitRepo {
3409 #[serde(default, skip_serializing_if = "Option::is_none")]
3410 pub directory: Option<String>,
3411 pub repository: String,
3412 #[serde(default, skip_serializing_if = "Option::is_none")]
3413 pub revision: Option<String>,
3414}
3415
3416#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3417pub struct PrometheusVolumesGlusterfs {
3418 pub endpoints: String,
3419 pub path: String,
3420 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3421 pub read_only: Option<bool>,
3422}
3423
3424#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3425pub struct PrometheusVolumesHostPath {
3426 pub path: String,
3427 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
3428 pub r#type: Option<String>,
3429}
3430
3431#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3432pub struct PrometheusVolumesIscsi {
3433 #[serde(default, skip_serializing_if = "Option::is_none", rename = "chapAuthDiscovery")]
3434 pub chap_auth_discovery: Option<bool>,
3435 #[serde(default, skip_serializing_if = "Option::is_none", rename = "chapAuthSession")]
3436 pub chap_auth_session: Option<bool>,
3437 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3438 pub fs_type: Option<String>,
3439 #[serde(default, skip_serializing_if = "Option::is_none", rename = "initiatorName")]
3440 pub initiator_name: Option<String>,
3441 pub iqn: String,
3442 #[serde(default, skip_serializing_if = "Option::is_none", rename = "iscsiInterface")]
3443 pub iscsi_interface: Option<String>,
3444 pub lun: i32,
3445 #[serde(default, skip_serializing_if = "Option::is_none")]
3446 pub portals: Option<Vec<String>>,
3447 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3448 pub read_only: Option<bool>,
3449 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
3450 pub secret_ref: Option<PrometheusVolumesIscsiSecretRef>,
3451 #[serde(rename = "targetPortal")]
3452 pub target_portal: String,
3453}
3454
3455#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3456pub struct PrometheusVolumesIscsiSecretRef {
3457 #[serde(default, skip_serializing_if = "Option::is_none")]
3458 pub name: Option<String>,
3459}
3460
3461#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3462pub struct PrometheusVolumesNfs {
3463 pub path: String,
3464 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3465 pub read_only: Option<bool>,
3466 pub server: String,
3467}
3468
3469#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3470pub struct PrometheusVolumesPersistentVolumeClaim {
3471 #[serde(rename = "claimName")]
3472 pub claim_name: String,
3473 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3474 pub read_only: Option<bool>,
3475}
3476
3477#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3478pub struct PrometheusVolumesPhotonPersistentDisk {
3479 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3480 pub fs_type: Option<String>,
3481 #[serde(rename = "pdID")]
3482 pub pd_id: String,
3483}
3484
3485#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3486pub struct PrometheusVolumesPortworxVolume {
3487 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3488 pub fs_type: Option<String>,
3489 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3490 pub read_only: Option<bool>,
3491 #[serde(rename = "volumeID")]
3492 pub volume_id: String,
3493}
3494
3495#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3496pub struct PrometheusVolumesProjected {
3497 #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
3498 pub default_mode: Option<i32>,
3499 #[serde(default, skip_serializing_if = "Option::is_none")]
3500 pub sources: Option<Vec<PrometheusVolumesProjectedSources>>,
3501}
3502
3503#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3504pub struct PrometheusVolumesProjectedSources {
3505 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
3506 pub config_map: Option<PrometheusVolumesProjectedSourcesConfigMap>,
3507 #[serde(default, skip_serializing_if = "Option::is_none", rename = "downwardAPI")]
3508 pub downward_api: Option<PrometheusVolumesProjectedSourcesDownwardApi>,
3509 #[serde(default, skip_serializing_if = "Option::is_none")]
3510 pub secret: Option<PrometheusVolumesProjectedSourcesSecret>,
3511 #[serde(default, skip_serializing_if = "Option::is_none", rename = "serviceAccountToken")]
3512 pub service_account_token: Option<PrometheusVolumesProjectedSourcesServiceAccountToken>,
3513}
3514
3515#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3516pub struct PrometheusVolumesProjectedSourcesConfigMap {
3517 #[serde(default, skip_serializing_if = "Option::is_none")]
3518 pub items: Option<Vec<PrometheusVolumesProjectedSourcesConfigMapItems>>,
3519 #[serde(default, skip_serializing_if = "Option::is_none")]
3520 pub name: Option<String>,
3521 #[serde(default, skip_serializing_if = "Option::is_none")]
3522 pub optional: Option<bool>,
3523}
3524
3525#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3526pub struct PrometheusVolumesProjectedSourcesConfigMapItems {
3527 pub key: String,
3528 #[serde(default, skip_serializing_if = "Option::is_none")]
3529 pub mode: Option<i32>,
3530 pub path: String,
3531}
3532
3533#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3534pub struct PrometheusVolumesProjectedSourcesDownwardApi {
3535 #[serde(default, skip_serializing_if = "Option::is_none")]
3536 pub items: Option<Vec<PrometheusVolumesProjectedSourcesDownwardApiItems>>,
3537}
3538
3539#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3540pub struct PrometheusVolumesProjectedSourcesDownwardApiItems {
3541 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fieldRef")]
3542 pub field_ref: Option<PrometheusVolumesProjectedSourcesDownwardApiItemsFieldRef>,
3543 #[serde(default, skip_serializing_if = "Option::is_none")]
3544 pub mode: Option<i32>,
3545 pub path: String,
3546 #[serde(default, skip_serializing_if = "Option::is_none", rename = "resourceFieldRef")]
3547 pub resource_field_ref: Option<PrometheusVolumesProjectedSourcesDownwardApiItemsResourceFieldRef>,
3548}
3549
3550#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3551pub struct PrometheusVolumesProjectedSourcesDownwardApiItemsFieldRef {
3552 #[serde(default, skip_serializing_if = "Option::is_none", rename = "apiVersion")]
3553 pub api_version: Option<String>,
3554 #[serde(rename = "fieldPath")]
3555 pub field_path: String,
3556}
3557
3558#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3559pub struct PrometheusVolumesProjectedSourcesDownwardApiItemsResourceFieldRef {
3560 #[serde(default, skip_serializing_if = "Option::is_none", rename = "containerName")]
3561 pub container_name: Option<String>,
3562 #[serde(default, skip_serializing_if = "Option::is_none")]
3563 pub divisor: Option<IntOrString>,
3564 pub resource: String,
3565}
3566
3567#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3568pub struct PrometheusVolumesProjectedSourcesSecret {
3569 #[serde(default, skip_serializing_if = "Option::is_none")]
3570 pub items: Option<Vec<PrometheusVolumesProjectedSourcesSecretItems>>,
3571 #[serde(default, skip_serializing_if = "Option::is_none")]
3572 pub name: Option<String>,
3573 #[serde(default, skip_serializing_if = "Option::is_none")]
3574 pub optional: Option<bool>,
3575}
3576
3577#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3578pub struct PrometheusVolumesProjectedSourcesSecretItems {
3579 pub key: String,
3580 #[serde(default, skip_serializing_if = "Option::is_none")]
3581 pub mode: Option<i32>,
3582 pub path: String,
3583}
3584
3585#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3586pub struct PrometheusVolumesProjectedSourcesServiceAccountToken {
3587 #[serde(default, skip_serializing_if = "Option::is_none")]
3588 pub audience: Option<String>,
3589 #[serde(default, skip_serializing_if = "Option::is_none", rename = "expirationSeconds")]
3590 pub expiration_seconds: Option<i64>,
3591 pub path: String,
3592}
3593
3594#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3595pub struct PrometheusVolumesQuobyte {
3596 #[serde(default, skip_serializing_if = "Option::is_none")]
3597 pub group: Option<String>,
3598 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3599 pub read_only: Option<bool>,
3600 pub registry: String,
3601 #[serde(default, skip_serializing_if = "Option::is_none")]
3602 pub tenant: Option<String>,
3603 #[serde(default, skip_serializing_if = "Option::is_none")]
3604 pub user: Option<String>,
3605 pub volume: String,
3606}
3607
3608#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3609pub struct PrometheusVolumesRbd {
3610 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3611 pub fs_type: Option<String>,
3612 pub image: String,
3613 #[serde(default, skip_serializing_if = "Option::is_none")]
3614 pub keyring: Option<String>,
3615 pub monitors: Vec<String>,
3616 #[serde(default, skip_serializing_if = "Option::is_none")]
3617 pub pool: Option<String>,
3618 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3619 pub read_only: Option<bool>,
3620 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
3621 pub secret_ref: Option<PrometheusVolumesRbdSecretRef>,
3622 #[serde(default, skip_serializing_if = "Option::is_none")]
3623 pub user: Option<String>,
3624}
3625
3626#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3627pub struct PrometheusVolumesRbdSecretRef {
3628 #[serde(default, skip_serializing_if = "Option::is_none")]
3629 pub name: Option<String>,
3630}
3631
3632#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3633pub struct PrometheusVolumesScaleIo {
3634 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3635 pub fs_type: Option<String>,
3636 pub gateway: String,
3637 #[serde(default, skip_serializing_if = "Option::is_none", rename = "protectionDomain")]
3638 pub protection_domain: Option<String>,
3639 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3640 pub read_only: Option<bool>,
3641 #[serde(rename = "secretRef")]
3642 pub secret_ref: PrometheusVolumesScaleIoSecretRef,
3643 #[serde(default, skip_serializing_if = "Option::is_none", rename = "sslEnabled")]
3644 pub ssl_enabled: Option<bool>,
3645 #[serde(default, skip_serializing_if = "Option::is_none", rename = "storageMode")]
3646 pub storage_mode: Option<String>,
3647 #[serde(default, skip_serializing_if = "Option::is_none", rename = "storagePool")]
3648 pub storage_pool: Option<String>,
3649 pub system: String,
3650 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
3651 pub volume_name: Option<String>,
3652}
3653
3654#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3655pub struct PrometheusVolumesScaleIoSecretRef {
3656 #[serde(default, skip_serializing_if = "Option::is_none")]
3657 pub name: Option<String>,
3658}
3659
3660#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3661pub struct PrometheusVolumesSecret {
3662 #[serde(default, skip_serializing_if = "Option::is_none", rename = "defaultMode")]
3663 pub default_mode: Option<i32>,
3664 #[serde(default, skip_serializing_if = "Option::is_none")]
3665 pub items: Option<Vec<PrometheusVolumesSecretItems>>,
3666 #[serde(default, skip_serializing_if = "Option::is_none")]
3667 pub optional: Option<bool>,
3668 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretName")]
3669 pub secret_name: Option<String>,
3670}
3671
3672#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3673pub struct PrometheusVolumesSecretItems {
3674 pub key: String,
3675 #[serde(default, skip_serializing_if = "Option::is_none")]
3676 pub mode: Option<i32>,
3677 pub path: String,
3678}
3679
3680#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3681pub struct PrometheusVolumesStorageos {
3682 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3683 pub fs_type: Option<String>,
3684 #[serde(default, skip_serializing_if = "Option::is_none", rename = "readOnly")]
3685 pub read_only: Option<bool>,
3686 #[serde(default, skip_serializing_if = "Option::is_none", rename = "secretRef")]
3687 pub secret_ref: Option<PrometheusVolumesStorageosSecretRef>,
3688 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeName")]
3689 pub volume_name: Option<String>,
3690 #[serde(default, skip_serializing_if = "Option::is_none", rename = "volumeNamespace")]
3691 pub volume_namespace: Option<String>,
3692}
3693
3694#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3695pub struct PrometheusVolumesStorageosSecretRef {
3696 #[serde(default, skip_serializing_if = "Option::is_none")]
3697 pub name: Option<String>,
3698}
3699
3700#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3701pub struct PrometheusVolumesVsphereVolume {
3702 #[serde(default, skip_serializing_if = "Option::is_none", rename = "fsType")]
3703 pub fs_type: Option<String>,
3704 #[serde(default, skip_serializing_if = "Option::is_none", rename = "storagePolicyID")]
3705 pub storage_policy_id: Option<String>,
3706 #[serde(default, skip_serializing_if = "Option::is_none", rename = "storagePolicyName")]
3707 pub storage_policy_name: Option<String>,
3708 #[serde(rename = "volumePath")]
3709 pub volume_path: String,
3710}
3711
3712#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3713pub struct PrometheusWeb {
3714 #[serde(default, skip_serializing_if = "Option::is_none", rename = "httpConfig")]
3715 pub http_config: Option<PrometheusWebHttpConfig>,
3716 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxConnections")]
3717 pub max_connections: Option<i32>,
3718 #[serde(default, skip_serializing_if = "Option::is_none", rename = "pageTitle")]
3719 pub page_title: Option<String>,
3720 #[serde(default, skip_serializing_if = "Option::is_none", rename = "tlsConfig")]
3721 pub tls_config: Option<PrometheusWebTlsConfig>,
3722}
3723
3724#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3725pub struct PrometheusWebHttpConfig {
3726 #[serde(default, skip_serializing_if = "Option::is_none")]
3727 pub headers: Option<PrometheusWebHttpConfigHeaders>,
3728 #[serde(default, skip_serializing_if = "Option::is_none")]
3729 pub http2: Option<bool>,
3730}
3731
3732#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3733pub struct PrometheusWebHttpConfigHeaders {
3734 #[serde(default, skip_serializing_if = "Option::is_none", rename = "contentSecurityPolicy")]
3735 pub content_security_policy: Option<String>,
3736 #[serde(default, skip_serializing_if = "Option::is_none", rename = "strictTransportSecurity")]
3737 pub strict_transport_security: Option<String>,
3738 #[serde(default, skip_serializing_if = "Option::is_none", rename = "xContentTypeOptions")]
3739 pub x_content_type_options: Option<PrometheusWebHttpConfigHeadersXContentTypeOptions>,
3740 #[serde(default, skip_serializing_if = "Option::is_none", rename = "xFrameOptions")]
3741 pub x_frame_options: Option<PrometheusWebHttpConfigHeadersXFrameOptions>,
3742 #[serde(default, skip_serializing_if = "Option::is_none", rename = "xXSSProtection")]
3743 pub x_xss_protection: Option<String>,
3744}
3745
3746#[derive(Serialize, Deserialize, Clone, Debug)]
3747pub enum PrometheusWebHttpConfigHeadersXContentTypeOptions {
3748 #[serde(rename = "")]
3749 KopiumEmpty,
3750 NoSniff,
3751}
3752
3753#[derive(Serialize, Deserialize, Clone, Debug)]
3754pub enum PrometheusWebHttpConfigHeadersXFrameOptions {
3755 #[serde(rename = "")]
3756 KopiumEmpty,
3757 Deny,
3758 SameOrigin,
3759}
3760
3761#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3762pub struct PrometheusWebTlsConfig {
3763 pub cert: PrometheusWebTlsConfigCert,
3764 #[serde(default, skip_serializing_if = "Option::is_none", rename = "cipherSuites")]
3765 pub cipher_suites: Option<Vec<String>>,
3766 #[serde(default, skip_serializing_if = "Option::is_none", rename = "clientAuthType")]
3767 pub client_auth_type: Option<String>,
3768 #[serde(default, skip_serializing_if = "Option::is_none")]
3769 pub client_ca: Option<PrometheusWebTlsConfigClientCa>,
3770 #[serde(default, skip_serializing_if = "Option::is_none", rename = "curvePreferences")]
3771 pub curve_preferences: Option<Vec<String>>,
3772 #[serde(rename = "keySecret")]
3773 pub key_secret: PrometheusWebTlsConfigKeySecret,
3774 #[serde(default, skip_serializing_if = "Option::is_none", rename = "maxVersion")]
3775 pub max_version: Option<String>,
3776 #[serde(default, skip_serializing_if = "Option::is_none", rename = "minVersion")]
3777 pub min_version: Option<String>,
3778 #[serde(default, skip_serializing_if = "Option::is_none", rename = "preferServerCipherSuites")]
3779 pub prefer_server_cipher_suites: Option<bool>,
3780}
3781
3782#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3783pub struct PrometheusWebTlsConfigCert {
3784 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
3785 pub config_map: Option<PrometheusWebTlsConfigCertConfigMap>,
3786 #[serde(default, skip_serializing_if = "Option::is_none")]
3787 pub secret: Option<PrometheusWebTlsConfigCertSecret>,
3788}
3789
3790#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3791pub struct PrometheusWebTlsConfigCertConfigMap {
3792 pub key: String,
3793 #[serde(default, skip_serializing_if = "Option::is_none")]
3794 pub name: Option<String>,
3795 #[serde(default, skip_serializing_if = "Option::is_none")]
3796 pub optional: Option<bool>,
3797}
3798
3799#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3800pub struct PrometheusWebTlsConfigCertSecret {
3801 pub key: String,
3802 #[serde(default, skip_serializing_if = "Option::is_none")]
3803 pub name: Option<String>,
3804 #[serde(default, skip_serializing_if = "Option::is_none")]
3805 pub optional: Option<bool>,
3806}
3807
3808#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3809pub struct PrometheusWebTlsConfigClientCa {
3810 #[serde(default, skip_serializing_if = "Option::is_none", rename = "configMap")]
3811 pub config_map: Option<PrometheusWebTlsConfigClientCaConfigMap>,
3812 #[serde(default, skip_serializing_if = "Option::is_none")]
3813 pub secret: Option<PrometheusWebTlsConfigClientCaSecret>,
3814}
3815
3816#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3817pub struct PrometheusWebTlsConfigClientCaConfigMap {
3818 pub key: String,
3819 #[serde(default, skip_serializing_if = "Option::is_none")]
3820 pub name: Option<String>,
3821 #[serde(default, skip_serializing_if = "Option::is_none")]
3822 pub optional: Option<bool>,
3823}
3824
3825#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3826pub struct PrometheusWebTlsConfigClientCaSecret {
3827 pub key: String,
3828 #[serde(default, skip_serializing_if = "Option::is_none")]
3829 pub name: Option<String>,
3830 #[serde(default, skip_serializing_if = "Option::is_none")]
3831 pub optional: Option<bool>,
3832}
3833
3834#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3835pub struct PrometheusWebTlsConfigKeySecret {
3836 pub key: String,
3837 #[serde(default, skip_serializing_if = "Option::is_none")]
3838 pub name: Option<String>,
3839 #[serde(default, skip_serializing_if = "Option::is_none")]
3840 pub optional: Option<bool>,
3841}
3842
3843#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3844pub struct PrometheusStatus {
3845 #[serde(rename = "availableReplicas")]
3846 pub available_replicas: i32,
3847 #[serde(default, skip_serializing_if = "Option::is_none")]
3848 pub conditions: Option<Vec<PrometheusStatusConditions>>,
3849 pub paused: bool,
3850 pub replicas: i32,
3851 #[serde(default, skip_serializing_if = "Option::is_none", rename = "shardStatuses")]
3852 pub shard_statuses: Option<Vec<PrometheusStatusShardStatuses>>,
3853 #[serde(rename = "unavailableReplicas")]
3854 pub unavailable_replicas: i32,
3855 #[serde(rename = "updatedReplicas")]
3856 pub updated_replicas: i32,
3857}
3858
3859#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3860pub struct PrometheusStatusConditions {
3861 #[serde(rename = "lastTransitionTime")]
3862 pub last_transition_time: String,
3863 #[serde(default, skip_serializing_if = "Option::is_none")]
3864 pub message: Option<String>,
3865 #[serde(default, skip_serializing_if = "Option::is_none", rename = "observedGeneration")]
3866 pub observed_generation: Option<i64>,
3867 #[serde(default, skip_serializing_if = "Option::is_none")]
3868 pub reason: Option<String>,
3869 pub status: String,
3870 #[serde(rename = "type")]
3871 pub r#type: String,
3872}
3873
3874#[derive(Serialize, Deserialize, Clone, Debug, Default)]
3875pub struct PrometheusStatusShardStatuses {
3876 #[serde(rename = "availableReplicas")]
3877 pub available_replicas: i32,
3878 pub replicas: i32,
3879 #[serde(rename = "shardID")]
3880 pub shard_id: String,
3881 #[serde(rename = "unavailableReplicas")]
3882 pub unavailable_replicas: i32,
3883 #[serde(rename = "updatedReplicas")]
3884 pub updated_replicas: i32,
3885}