1pub mod argoproj_io {
5 pub mod v1alpha1 {
6 pub mod analysis_run {
7 #[derive(serde::Deserialize, Debug, PartialEq)]
8 pub struct AnalysisRun {
9 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
10 pub spec: Spec,
11 pub status: Status,
12 }
13
14 impl k8s_openapi::Resource for AnalysisRun {
15 type Scope = k8s_openapi::ClusterResourceScope;
16
17 const API_VERSION: &'static str = "argoproj.io/v1alpha1";
18 const GROUP: &'static str = "argoproj.io";
19 const KIND: &'static str = "AnalysisRun";
20 const VERSION: &'static str = "v1alpha1";
21 const URL_PATH_SEGMENT: &'static str = "TODO";
22 }
23
24 impl k8s_openapi::Metadata for AnalysisRun {
25 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
26
27 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
28 &self.metadata
29 }
30
31 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
32 &mut self.metadata
33 }
34 }
35
36 impl serde::Serialize for AnalysisRun {
37 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
38 where
39 S: serde::Serializer,
40 {
41 use serde::ser::SerializeStruct;
42 let mut state = serializer.serialize_struct("AnalysisRun", 5)?;
43 state.serialize_field(
44 "apiVersion",
45 <Self as k8s_openapi::Resource>::API_VERSION,
46 )?;
47 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
48 state.serialize_field("metadata", &self.metadata)?;
49 state.serialize_field("spec", &self.spec)?;
50 state.serialize_field("status", &self.status)?;
51 state.end()
52 }
53 }
54
55 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
56 #[serde(rename_all = "camelCase")]
57 pub struct Affinity {
58 pub node_affinity: NodeAffinity,
59 pub pod_affinity: PodAffinity,
60 pub pod_anti_affinity: PodAntiAffinity,
61 }
62
63 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
64 #[serde(rename_all = "camelCase")]
65 pub struct JobMetadataAnnotations {
66 pub properties: std::collections::HashMap<String, String>,
67 }
68
69 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
70 #[serde(rename_all = "camelCase")]
71 pub struct TemplateMetadataAnnotations {
72 pub properties: std::collections::HashMap<String, String>,
73 }
74
75 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
76 #[serde(rename_all = "camelCase")]
77 pub struct ArgsItem {
78 pub name: String,
79 pub value: String,
80 pub value_from: ArgsItemValueFrom,
81 }
82
83 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
84 #[serde(rename_all = "camelCase")]
85 pub struct ContainersItemSecurityContextCapabilities {
86 pub add: Vec<String>,
87 pub drop: Vec<String>,
88 }
89
90 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
91 #[serde(rename_all = "camelCase")]
92 pub struct EphemeralContainersItemSecurityContextCapabilities {
93 pub add: Vec<String>,
94 pub drop: Vec<String>,
95 }
96
97 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
98 #[serde(rename_all = "camelCase")]
99 pub struct InitContainersItemSecurityContextCapabilities {
100 pub add: Vec<String>,
101 pub drop: Vec<String>,
102 }
103
104 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
105 #[serde(rename_all = "camelCase")]
106 pub struct CloudWatch {
107 pub interval: String,
108 pub metric_data_queries: Vec<MetricDataQueriesItem>,
109 }
110
111 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
112 #[serde(rename_all = "camelCase")]
113 pub struct ContainersItemEnvItemValueFromConfigMapKeyRef {
114 pub key: String,
115 pub name: String,
116 pub optional: bool,
117 }
118
119 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
120 #[serde(rename_all = "camelCase")]
121 pub struct EphemeralContainersItemEnvItemValueFromConfigMapKeyRef {
122 pub key: String,
123 pub name: String,
124 pub optional: bool,
125 }
126
127 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
128 #[serde(rename_all = "camelCase")]
129 pub struct InitContainersItemEnvItemValueFromConfigMapKeyRef {
130 pub key: String,
131 pub name: String,
132 pub optional: bool,
133 }
134
135 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
136 #[serde(rename_all = "camelCase")]
137 pub struct ContainersItemEnvFromItemConfigMapRef {
138 pub name: String,
139 pub optional: bool,
140 }
141
142 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
143 #[serde(rename_all = "camelCase")]
144 pub struct EphemeralContainersItemEnvFromItemConfigMapRef {
145 pub name: String,
146 pub optional: bool,
147 }
148
149 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
150 #[serde(rename_all = "camelCase")]
151 pub struct InitContainersItemEnvFromItemConfigMapRef {
152 pub name: String,
153 pub optional: bool,
154 }
155
156 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
157 #[serde(rename_all = "camelCase")]
158 pub struct ContainersItem {
159 pub args: Vec<String>,
160 pub command: Vec<String>,
161 pub env: Vec<ContainersItemEnvItem>,
162 pub env_from: Vec<ContainersItemEnvFromItem>,
163 pub image: String,
164 pub image_pull_policy: String,
165 pub lifecycle: ContainersItemLifecycle,
166 pub liveness_probe: ContainersItemLivenessProbe,
167 pub name: String,
168 pub ports: Vec<ContainersItemPortsItem>,
169 pub readiness_probe: ContainersItemReadinessProbe,
170 pub resources: ContainersItemResources,
171 pub security_context: ContainersItemSecurityContext,
172 pub startup_probe: ContainersItemStartupProbe,
173 pub stdin: bool,
174 pub stdin_once: bool,
175 pub termination_message_path: String,
176 pub termination_message_policy: String,
177 pub tty: bool,
178 pub volume_devices: Vec<ContainersItemVolumeDevicesItem>,
179 pub volume_mounts: Vec<ContainersItemVolumeMountsItem>,
180 pub working_dir: String,
181 }
182
183 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
184 #[serde(rename_all = "camelCase")]
185 pub struct ControlScope {
186 pub end: String,
187 pub region: String,
188 pub scope: String,
189 pub start: String,
190 pub step: i64,
191 }
192
193 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
194 #[serde(rename_all = "camelCase")]
195 pub struct Datadog {
196 pub interval: String,
197 pub query: String,
198 }
199
200 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
201 #[serde(rename_all = "camelCase")]
202 pub struct DimensionsItem {
203 pub name: String,
204 pub value: String,
205 }
206
207 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
208 #[serde(rename_all = "camelCase")]
209 pub struct DnsConfig {
210 pub nameservers: Vec<String>,
211 pub options: Vec<OptionsItem>,
212 pub searches: Vec<String>,
213 }
214
215 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
216 #[serde(rename_all = "camelCase")]
217 pub struct DryRunItem {
218 pub metric_name: String,
219 }
220
221 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
222 #[serde(rename_all = "camelCase")]
223 pub struct DryRunSummary {
224 pub count: i32,
225 pub error: i32,
226 pub failed: i32,
227 pub inconclusive: i32,
228 pub successful: i32,
229 }
230
231 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
232 #[serde(rename_all = "camelCase")]
233 pub struct ContainersItemEnvFromItem {
234 pub config_map_ref: ContainersItemEnvFromItemConfigMapRef,
235 pub prefix: String,
236 pub secret_ref: ContainersItemEnvFromItemSecretRef,
237 }
238
239 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
240 #[serde(rename_all = "camelCase")]
241 pub struct EphemeralContainersItemEnvFromItem {
242 pub config_map_ref: EphemeralContainersItemEnvFromItemConfigMapRef,
243 pub prefix: String,
244 pub secret_ref: EphemeralContainersItemEnvFromItemSecretRef,
245 }
246
247 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
248 #[serde(rename_all = "camelCase")]
249 pub struct InitContainersItemEnvFromItem {
250 pub config_map_ref: InitContainersItemEnvFromItemConfigMapRef,
251 pub prefix: String,
252 pub secret_ref: InitContainersItemEnvFromItemSecretRef,
253 }
254
255 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
256 #[serde(rename_all = "camelCase")]
257 pub struct ContainersItemEnvItem {
258 pub name: String,
259 pub value: String,
260 pub value_from: ContainersItemEnvItemValueFrom,
261 }
262
263 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
264 #[serde(rename_all = "camelCase")]
265 pub struct EphemeralContainersItemEnvItem {
266 pub name: String,
267 pub value: String,
268 pub value_from: EphemeralContainersItemEnvItemValueFrom,
269 }
270
271 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
272 #[serde(rename_all = "camelCase")]
273 pub struct InitContainersItemEnvItem {
274 pub name: String,
275 pub value: String,
276 pub value_from: InitContainersItemEnvItemValueFrom,
277 }
278
279 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
280 #[serde(rename_all = "camelCase")]
281 pub struct EphemeralContainersItem {
282 pub args: Vec<String>,
283 pub command: Vec<String>,
284 pub env: Vec<EphemeralContainersItemEnvItem>,
285 pub env_from: Vec<EphemeralContainersItemEnvFromItem>,
286 pub image: String,
287 pub image_pull_policy: String,
288 pub lifecycle: EphemeralContainersItemLifecycle,
289 pub liveness_probe: EphemeralContainersItemLivenessProbe,
290 pub name: String,
291 pub ports: Vec<EphemeralContainersItemPortsItem>,
292 pub readiness_probe: EphemeralContainersItemReadinessProbe,
293 pub resources: EphemeralContainersItemResources,
294 pub security_context: EphemeralContainersItemSecurityContext,
295 pub startup_probe: EphemeralContainersItemStartupProbe,
296 pub stdin: bool,
297 pub stdin_once: bool,
298 pub target_container_name: String,
299 pub termination_message_path: String,
300 pub termination_message_policy: String,
301 pub tty: bool,
302 pub volume_devices: Vec<EphemeralContainersItemVolumeDevicesItem>,
303 pub volume_mounts: Vec<EphemeralContainersItemVolumeMountsItem>,
304 pub working_dir: String,
305 }
306
307 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
308 #[serde(rename_all = "camelCase")]
309 pub struct ContainersItemLifecyclePostStartExec {
310 pub command: Vec<String>,
311 }
312
313 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
314 #[serde(rename_all = "camelCase")]
315 pub struct ContainersItemLifecyclePreStopExec {
316 pub command: Vec<String>,
317 }
318
319 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
320 #[serde(rename_all = "camelCase")]
321 pub struct ContainersItemLivenessProbeExec {
322 pub command: Vec<String>,
323 }
324
325 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
326 #[serde(rename_all = "camelCase")]
327 pub struct ContainersItemReadinessProbeExec {
328 pub command: Vec<String>,
329 }
330
331 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
332 #[serde(rename_all = "camelCase")]
333 pub struct ContainersItemStartupProbeExec {
334 pub command: Vec<String>,
335 }
336
337 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
338 #[serde(rename_all = "camelCase")]
339 pub struct EphemeralContainersItemLifecyclePostStartExec {
340 pub command: Vec<String>,
341 }
342
343 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
344 #[serde(rename_all = "camelCase")]
345 pub struct EphemeralContainersItemLifecyclePreStopExec {
346 pub command: Vec<String>,
347 }
348
349 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
350 #[serde(rename_all = "camelCase")]
351 pub struct EphemeralContainersItemLivenessProbeExec {
352 pub command: Vec<String>,
353 }
354
355 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
356 #[serde(rename_all = "camelCase")]
357 pub struct EphemeralContainersItemReadinessProbeExec {
358 pub command: Vec<String>,
359 }
360
361 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
362 #[serde(rename_all = "camelCase")]
363 pub struct EphemeralContainersItemStartupProbeExec {
364 pub command: Vec<String>,
365 }
366
367 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
368 #[serde(rename_all = "camelCase")]
369 pub struct InitContainersItemLifecyclePostStartExec {
370 pub command: Vec<String>,
371 }
372
373 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
374 #[serde(rename_all = "camelCase")]
375 pub struct InitContainersItemLifecyclePreStopExec {
376 pub command: Vec<String>,
377 }
378
379 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
380 #[serde(rename_all = "camelCase")]
381 pub struct InitContainersItemLivenessProbeExec {
382 pub command: Vec<String>,
383 }
384
385 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
386 #[serde(rename_all = "camelCase")]
387 pub struct InitContainersItemReadinessProbeExec {
388 pub command: Vec<String>,
389 }
390
391 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
392 #[serde(rename_all = "camelCase")]
393 pub struct InitContainersItemStartupProbeExec {
394 pub command: Vec<String>,
395 }
396
397 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
398 #[serde(rename_all = "camelCase")]
399 pub struct ExperimentScope {
400 pub end: String,
401 pub region: String,
402 pub scope: String,
403 pub start: String,
404 pub step: i64,
405 }
406
407 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
408 #[serde(rename_all = "camelCase")]
409 pub struct ArgsItemValueFromFieldRef {
410 pub field_path: String,
411 }
412
413 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
414 #[serde(rename_all = "camelCase")]
415 pub struct ContainersItemEnvItemValueFromFieldRef {
416 pub api_version: String,
417 pub field_path: String,
418 }
419
420 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
421 #[serde(rename_all = "camelCase")]
422 pub struct EphemeralContainersItemEnvItemValueFromFieldRef {
423 pub api_version: String,
424 pub field_path: String,
425 }
426
427 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
428 #[serde(rename_all = "camelCase")]
429 pub struct InitContainersItemEnvItemValueFromFieldRef {
430 pub api_version: String,
431 pub field_path: String,
432 }
433
434 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
435 #[serde(rename_all = "camelCase")]
436 pub struct Graphite {
437 pub address: String,
438 pub query: String,
439 }
440
441 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
442 #[serde(rename_all = "camelCase")]
443 pub struct ContainersItemLivenessProbeGrpc {
444 pub port: i32,
445 pub service: String,
446 }
447
448 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
449 #[serde(rename_all = "camelCase")]
450 pub struct ContainersItemReadinessProbeGrpc {
451 pub port: i32,
452 pub service: String,
453 }
454
455 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
456 #[serde(rename_all = "camelCase")]
457 pub struct ContainersItemStartupProbeGrpc {
458 pub port: i32,
459 pub service: String,
460 }
461
462 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
463 #[serde(rename_all = "camelCase")]
464 pub struct EphemeralContainersItemLivenessProbeGrpc {
465 pub port: i32,
466 pub service: String,
467 }
468
469 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
470 #[serde(rename_all = "camelCase")]
471 pub struct EphemeralContainersItemReadinessProbeGrpc {
472 pub port: i32,
473 pub service: String,
474 }
475
476 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
477 #[serde(rename_all = "camelCase")]
478 pub struct EphemeralContainersItemStartupProbeGrpc {
479 pub port: i32,
480 pub service: String,
481 }
482
483 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
484 #[serde(rename_all = "camelCase")]
485 pub struct InitContainersItemLivenessProbeGrpc {
486 pub port: i32,
487 pub service: String,
488 }
489
490 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
491 #[serde(rename_all = "camelCase")]
492 pub struct InitContainersItemReadinessProbeGrpc {
493 pub port: i32,
494 pub service: String,
495 }
496
497 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
498 #[serde(rename_all = "camelCase")]
499 pub struct InitContainersItemStartupProbeGrpc {
500 pub port: i32,
501 pub service: String,
502 }
503
504 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
505 #[serde(rename_all = "camelCase")]
506 pub struct HeadersItem {
507 pub key: String,
508 pub value: String,
509 }
510
511 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
512 #[serde(rename_all = "camelCase")]
513 pub struct HostAliasesItem {
514 pub hostnames: Vec<String>,
515 pub ip: String,
516 }
517
518 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
519 #[serde(rename_all = "camelCase")]
520 pub struct ContainersItemLifecyclePostStartHttpGet {
521 pub host: String,
522 pub http_headers: Vec<ContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
523 pub path: String,
524 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
525 pub scheme: String,
526 }
527
528 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
529 #[serde(rename_all = "camelCase")]
530 pub struct ContainersItemLifecyclePreStopHttpGet {
531 pub host: String,
532 pub http_headers: Vec<ContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
533 pub path: String,
534 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
535 pub scheme: String,
536 }
537
538 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
539 #[serde(rename_all = "camelCase")]
540 pub struct ContainersItemLivenessProbeHttpGet {
541 pub host: String,
542 pub http_headers: Vec<ContainersItemLivenessProbeHttpGetHttpHeadersItem>,
543 pub path: String,
544 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
545 pub scheme: String,
546 }
547
548 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
549 #[serde(rename_all = "camelCase")]
550 pub struct ContainersItemReadinessProbeHttpGet {
551 pub host: String,
552 pub http_headers: Vec<ContainersItemReadinessProbeHttpGetHttpHeadersItem>,
553 pub path: String,
554 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
555 pub scheme: String,
556 }
557
558 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
559 #[serde(rename_all = "camelCase")]
560 pub struct ContainersItemStartupProbeHttpGet {
561 pub host: String,
562 pub http_headers: Vec<ContainersItemStartupProbeHttpGetHttpHeadersItem>,
563 pub path: String,
564 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
565 pub scheme: String,
566 }
567
568 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
569 #[serde(rename_all = "camelCase")]
570 pub struct EphemeralContainersItemLifecyclePostStartHttpGet {
571 pub host: String,
572 pub http_headers:
573 Vec<EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
574 pub path: String,
575 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
576 pub scheme: String,
577 }
578
579 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
580 #[serde(rename_all = "camelCase")]
581 pub struct EphemeralContainersItemLifecyclePreStopHttpGet {
582 pub host: String,
583 pub http_headers:
584 Vec<EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
585 pub path: String,
586 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
587 pub scheme: String,
588 }
589
590 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
591 #[serde(rename_all = "camelCase")]
592 pub struct EphemeralContainersItemLivenessProbeHttpGet {
593 pub host: String,
594 pub http_headers: Vec<EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem>,
595 pub path: String,
596 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
597 pub scheme: String,
598 }
599
600 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
601 #[serde(rename_all = "camelCase")]
602 pub struct EphemeralContainersItemReadinessProbeHttpGet {
603 pub host: String,
604 pub http_headers: Vec<EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem>,
605 pub path: String,
606 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
607 pub scheme: String,
608 }
609
610 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
611 #[serde(rename_all = "camelCase")]
612 pub struct EphemeralContainersItemStartupProbeHttpGet {
613 pub host: String,
614 pub http_headers: Vec<EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem>,
615 pub path: String,
616 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
617 pub scheme: String,
618 }
619
620 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
621 #[serde(rename_all = "camelCase")]
622 pub struct InitContainersItemLifecyclePostStartHttpGet {
623 pub host: String,
624 pub http_headers: Vec<InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
625 pub path: String,
626 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
627 pub scheme: String,
628 }
629
630 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
631 #[serde(rename_all = "camelCase")]
632 pub struct InitContainersItemLifecyclePreStopHttpGet {
633 pub host: String,
634 pub http_headers: Vec<InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
635 pub path: String,
636 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
637 pub scheme: String,
638 }
639
640 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
641 #[serde(rename_all = "camelCase")]
642 pub struct InitContainersItemLivenessProbeHttpGet {
643 pub host: String,
644 pub http_headers: Vec<InitContainersItemLivenessProbeHttpGetHttpHeadersItem>,
645 pub path: String,
646 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
647 pub scheme: String,
648 }
649
650 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
651 #[serde(rename_all = "camelCase")]
652 pub struct InitContainersItemReadinessProbeHttpGet {
653 pub host: String,
654 pub http_headers: Vec<InitContainersItemReadinessProbeHttpGetHttpHeadersItem>,
655 pub path: String,
656 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
657 pub scheme: String,
658 }
659
660 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
661 #[serde(rename_all = "camelCase")]
662 pub struct InitContainersItemStartupProbeHttpGet {
663 pub host: String,
664 pub http_headers: Vec<InitContainersItemStartupProbeHttpGetHttpHeadersItem>,
665 pub path: String,
666 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
667 pub scheme: String,
668 }
669
670 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
671 #[serde(rename_all = "camelCase")]
672 pub struct ContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
673 pub name: String,
674 pub value: String,
675 }
676
677 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
678 #[serde(rename_all = "camelCase")]
679 pub struct ContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
680 pub name: String,
681 pub value: String,
682 }
683
684 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
685 #[serde(rename_all = "camelCase")]
686 pub struct ContainersItemLivenessProbeHttpGetHttpHeadersItem {
687 pub name: String,
688 pub value: String,
689 }
690
691 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
692 #[serde(rename_all = "camelCase")]
693 pub struct ContainersItemReadinessProbeHttpGetHttpHeadersItem {
694 pub name: String,
695 pub value: String,
696 }
697
698 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
699 #[serde(rename_all = "camelCase")]
700 pub struct ContainersItemStartupProbeHttpGetHttpHeadersItem {
701 pub name: String,
702 pub value: String,
703 }
704
705 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
706 #[serde(rename_all = "camelCase")]
707 pub struct EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
708 pub name: String,
709 pub value: String,
710 }
711
712 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
713 #[serde(rename_all = "camelCase")]
714 pub struct EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
715 pub name: String,
716 pub value: String,
717 }
718
719 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
720 #[serde(rename_all = "camelCase")]
721 pub struct EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem {
722 pub name: String,
723 pub value: String,
724 }
725
726 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
727 #[serde(rename_all = "camelCase")]
728 pub struct EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem {
729 pub name: String,
730 pub value: String,
731 }
732
733 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
734 #[serde(rename_all = "camelCase")]
735 pub struct EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem {
736 pub name: String,
737 pub value: String,
738 }
739
740 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
741 #[serde(rename_all = "camelCase")]
742 pub struct InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
743 pub name: String,
744 pub value: String,
745 }
746
747 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
748 #[serde(rename_all = "camelCase")]
749 pub struct InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
750 pub name: String,
751 pub value: String,
752 }
753
754 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
755 #[serde(rename_all = "camelCase")]
756 pub struct InitContainersItemLivenessProbeHttpGetHttpHeadersItem {
757 pub name: String,
758 pub value: String,
759 }
760
761 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
762 #[serde(rename_all = "camelCase")]
763 pub struct InitContainersItemReadinessProbeHttpGetHttpHeadersItem {
764 pub name: String,
765 pub value: String,
766 }
767
768 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
769 #[serde(rename_all = "camelCase")]
770 pub struct InitContainersItemStartupProbeHttpGetHttpHeadersItem {
771 pub name: String,
772 pub value: String,
773 }
774
775 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
776 #[serde(rename_all = "camelCase")]
777 pub struct ImagePullSecretsItem {
778 pub name: String,
779 }
780
781 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
782 #[serde(rename_all = "camelCase")]
783 pub struct Influxdb {
784 pub profile: String,
785 pub query: String,
786 }
787
788 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
789 #[serde(rename_all = "camelCase")]
790 pub struct InitContainersItem {
791 pub args: Vec<String>,
792 pub command: Vec<String>,
793 pub env: Vec<InitContainersItemEnvItem>,
794 pub env_from: Vec<InitContainersItemEnvFromItem>,
795 pub image: String,
796 pub image_pull_policy: String,
797 pub lifecycle: InitContainersItemLifecycle,
798 pub liveness_probe: InitContainersItemLivenessProbe,
799 pub name: String,
800 pub ports: Vec<InitContainersItemPortsItem>,
801 pub readiness_probe: InitContainersItemReadinessProbe,
802 pub resources: InitContainersItemResources,
803 pub security_context: InitContainersItemSecurityContext,
804 pub startup_probe: InitContainersItemStartupProbe,
805 pub stdin: bool,
806 pub stdin_once: bool,
807 pub termination_message_path: String,
808 pub termination_message_policy: String,
809 pub tty: bool,
810 pub volume_devices: Vec<InitContainersItemVolumeDevicesItem>,
811 pub volume_mounts: Vec<InitContainersItemVolumeMountsItem>,
812 pub working_dir: String,
813 }
814
815 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
816 #[serde(rename_all = "camelCase")]
817 pub struct Job {
818 pub metadata: JobMetadata,
819 pub spec: JobSpec,
820 }
821
822 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
823 #[serde(rename_all = "camelCase")]
824 pub struct Kayenta {
825 pub address: String,
826 pub application: String,
827 pub canary_config_name: String,
828 pub configuration_account_name: String,
829 pub metrics_account_name: String,
830 pub scopes: Vec<ScopesItem>,
831 pub storage_account_name: String,
832 pub threshold: Threshold,
833 }
834
835 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
836 #[serde(rename_all = "camelCase")]
837 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
838 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
839 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
840 }
841
842 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
843 #[serde(rename_all = "camelCase")]
844 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
845 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
846 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
847 }
848
849 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
850 #[serde(rename_all = "camelCase")]
851 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
852 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
853 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
854 }
855
856 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
857 #[serde(rename_all = "camelCase")]
858 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
859 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
860 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
861 }
862
863 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
864 #[serde(rename_all = "camelCase")]
865 pub struct TopologySpreadConstraintsItemLabelSelector {
866 pub match_expressions:
867 Vec<TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem>,
868 pub match_labels: TopologySpreadConstraintsItemLabelSelectorMatchLabels,
869 }
870
871 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
872 #[serde(rename_all = "camelCase")]
873 pub struct JobMetadataLabels {
874 pub properties: std::collections::HashMap<String, String>,
875 }
876
877 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
878 #[serde(rename_all = "camelCase")]
879 pub struct TemplateMetadataLabels {
880 pub properties: std::collections::HashMap<String, String>,
881 }
882
883 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
884 #[serde(rename_all = "camelCase")]
885 pub struct ContainersItemLifecycle {
886 pub post_start: ContainersItemLifecyclePostStart,
887 pub pre_stop: ContainersItemLifecyclePreStop,
888 }
889
890 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
891 #[serde(rename_all = "camelCase")]
892 pub struct EphemeralContainersItemLifecycle {
893 pub post_start: EphemeralContainersItemLifecyclePostStart,
894 pub pre_stop: EphemeralContainersItemLifecyclePreStop,
895 }
896
897 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
898 #[serde(rename_all = "camelCase")]
899 pub struct InitContainersItemLifecycle {
900 pub post_start: InitContainersItemLifecyclePostStart,
901 pub pre_stop: InitContainersItemLifecyclePreStop,
902 }
903
904 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
905 #[serde(rename_all = "camelCase")]
906 pub struct ContainersItemLivenessProbe {
907 pub exec: ContainersItemLivenessProbeExec,
908 pub failure_threshold: i32,
909 pub grpc: ContainersItemLivenessProbeGrpc,
910 pub http_get: ContainersItemLivenessProbeHttpGet,
911 pub initial_delay_seconds: i32,
912 pub period_seconds: i32,
913 pub success_threshold: i32,
914 pub tcp_socket: ContainersItemLivenessProbeTcpSocket,
915 pub termination_grace_period_seconds: i64,
916 pub timeout_seconds: i32,
917 }
918
919 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
920 #[serde(rename_all = "camelCase")]
921 pub struct EphemeralContainersItemLivenessProbe {
922 pub exec: EphemeralContainersItemLivenessProbeExec,
923 pub failure_threshold: i32,
924 pub grpc: EphemeralContainersItemLivenessProbeGrpc,
925 pub http_get: EphemeralContainersItemLivenessProbeHttpGet,
926 pub initial_delay_seconds: i32,
927 pub period_seconds: i32,
928 pub success_threshold: i32,
929 pub tcp_socket: EphemeralContainersItemLivenessProbeTcpSocket,
930 pub termination_grace_period_seconds: i64,
931 pub timeout_seconds: i32,
932 }
933
934 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
935 #[serde(rename_all = "camelCase")]
936 pub struct InitContainersItemLivenessProbe {
937 pub exec: InitContainersItemLivenessProbeExec,
938 pub failure_threshold: i32,
939 pub grpc: InitContainersItemLivenessProbeGrpc,
940 pub http_get: InitContainersItemLivenessProbeHttpGet,
941 pub initial_delay_seconds: i32,
942 pub period_seconds: i32,
943 pub success_threshold: i32,
944 pub tcp_socket: InitContainersItemLivenessProbeTcpSocket,
945 pub termination_grace_period_seconds: i64,
946 pub timeout_seconds: i32,
947 }
948
949 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
950 #[serde(rename_all = "camelCase")]
951 pub struct SelectorMatchExpressionsItem {
952 pub key: String,
953 pub operator: String,
954 pub values: Vec<String>,
955 }
956
957 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
958 #[serde(rename_all = "camelCase")]
959 pub struct PreferenceMatchExpressionsItem {
960 pub key: String,
961 pub operator: String,
962 pub values: Vec<String>,
963 }
964
965 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
966 #[serde(rename_all = "camelCase")]
967 pub struct NodeSelectorTermsItemMatchExpressionsItem {
968 pub key: String,
969 pub operator: String,
970 pub values: Vec<String>,
971 }
972
973 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
974 #[serde(rename_all = "camelCase")]
975 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
976 {
977 pub key: String,
978 pub operator: String,
979 pub values: Vec<String>,
980 }
981
982 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
983 #[serde(rename_all = "camelCase")]
984 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
985 {
986 pub key: String,
987 pub operator: String,
988 pub values: Vec<String>,
989 }
990
991 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
992 #[serde(rename_all = "camelCase")]
993 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
994 {
995 pub key: String,
996 pub operator: String,
997 pub values: Vec<String>,
998 }
999
1000 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1001 #[serde(rename_all = "camelCase")]
1002 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
1003 {
1004 pub key: String,
1005 pub operator: String,
1006 pub values: Vec<String>,
1007 }
1008
1009 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1010 #[serde(rename_all = "camelCase")]
1011 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
1012 {
1013 pub key: String,
1014 pub operator: String,
1015 pub values: Vec<String>,
1016 }
1017
1018 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1019 #[serde(rename_all = "camelCase")]
1020 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
1021 {
1022 pub key: String,
1023 pub operator: String,
1024 pub values: Vec<String>,
1025 }
1026
1027 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1028 #[serde(rename_all = "camelCase")]
1029 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
1030 {
1031 pub key: String,
1032 pub operator: String,
1033 pub values: Vec<String>,
1034 }
1035
1036 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1037 #[serde(rename_all = "camelCase")]
1038 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
1039 {
1040 pub key: String,
1041 pub operator: String,
1042 pub values: Vec<String>,
1043 }
1044
1045 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1046 #[serde(rename_all = "camelCase")]
1047 pub struct TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem {
1048 pub key: String,
1049 pub operator: String,
1050 pub values: Vec<String>,
1051 }
1052
1053 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1054 #[serde(rename_all = "camelCase")]
1055 pub struct PreferenceMatchFieldsItem {
1056 pub key: String,
1057 pub operator: String,
1058 pub values: Vec<String>,
1059 }
1060
1061 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1062 #[serde(rename_all = "camelCase")]
1063 pub struct NodeSelectorTermsItemMatchFieldsItem {
1064 pub key: String,
1065 pub operator: String,
1066 pub values: Vec<String>,
1067 }
1068
1069 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1070 #[serde(rename_all = "camelCase")]
1071 pub struct SelectorMatchLabels {
1072 pub properties: std::collections::HashMap<String, String>,
1073 }
1074
1075 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1076 #[serde(rename_all = "camelCase")]
1077 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
1078 {
1079 pub properties: std::collections::HashMap<String, String>,
1080 }
1081
1082 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1083 #[serde(rename_all = "camelCase")]
1084 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
1085 {
1086 pub properties: std::collections::HashMap<String, String>,
1087 }
1088
1089 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1090 #[serde(rename_all = "camelCase")]
1091 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels {
1092 pub properties: std::collections::HashMap<String, String>,
1093 }
1094
1095 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1096 #[serde(rename_all = "camelCase")]
1097 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
1098 {
1099 pub properties: std::collections::HashMap<String, String>,
1100 }
1101
1102 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1103 #[serde(rename_all = "camelCase")]
1104 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
1105 {
1106 pub properties: std::collections::HashMap<String, String>,
1107 }
1108
1109 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1110 #[serde(rename_all = "camelCase")]
1111 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
1112 {
1113 pub properties: std::collections::HashMap<String, String>,
1114 }
1115
1116 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1117 #[serde(rename_all = "camelCase")]
1118 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels
1119 {
1120 pub properties: std::collections::HashMap<String, String>,
1121 }
1122
1123 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1124 #[serde(rename_all = "camelCase")]
1125 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
1126 {
1127 pub properties: std::collections::HashMap<String, String>,
1128 }
1129
1130 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1131 #[serde(rename_all = "camelCase")]
1132 pub struct TopologySpreadConstraintsItemLabelSelectorMatchLabels {
1133 pub properties: std::collections::HashMap<String, String>,
1134 }
1135
1136 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1137 #[serde(rename_all = "camelCase")]
1138 pub struct MeasurementRetentionItem {
1139 pub limit: i32,
1140 pub metric_name: String,
1141 }
1142
1143 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1144 #[serde(rename_all = "camelCase")]
1145 pub struct MeasurementsItem {
1146 pub finished_at: String,
1147 pub message: String,
1148 pub metadata: MeasurementsItemMetadata,
1149 pub phase: String,
1150 pub resume_at: String,
1151 pub started_at: String,
1152 pub value: String,
1153 }
1154
1155 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1156 #[serde(rename_all = "camelCase")]
1157 pub struct JobMetadata {
1158 pub annotations: JobMetadataAnnotations,
1159 pub labels: JobMetadataLabels,
1160 }
1161
1162 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1163 #[serde(rename_all = "camelCase")]
1164 pub struct TemplateMetadata {
1165 pub annotations: TemplateMetadataAnnotations,
1166 pub labels: TemplateMetadataLabels,
1167 }
1168
1169 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1170 #[serde(rename_all = "camelCase")]
1171 pub struct MetricResultsItemMetadata {
1172 pub properties: std::collections::HashMap<String, String>,
1173 }
1174
1175 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1176 #[serde(rename_all = "camelCase")]
1177 pub struct MeasurementsItemMetadata {
1178 pub properties: std::collections::HashMap<String, String>,
1179 }
1180
1181 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1182 #[serde(rename_all = "camelCase")]
1183 pub struct Metric {
1184 pub dimensions: Vec<DimensionsItem>,
1185 pub metric_name: String,
1186 pub namespace: String,
1187 }
1188
1189 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1190 #[serde(rename_all = "camelCase")]
1191 pub struct MetricDataQueriesItem {
1192 pub expression: String,
1193 pub id: String,
1194 pub label: String,
1195 pub metric_stat: MetricStat,
1196 pub period: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1197 pub return_data: bool,
1198 }
1199
1200 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1201 #[serde(rename_all = "camelCase")]
1202 pub struct MetricResultsItem {
1203 pub consecutive_error: i32,
1204 pub count: i32,
1205 pub dry_run: bool,
1206 pub error: i32,
1207 pub failed: i32,
1208 pub inconclusive: i32,
1209 pub measurements: Vec<MeasurementsItem>,
1210 pub message: String,
1211 pub metadata: MetricResultsItemMetadata,
1212 pub name: String,
1213 pub phase: String,
1214 pub successful: i32,
1215 }
1216
1217 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1218 #[serde(rename_all = "camelCase")]
1219 pub struct MetricStat {
1220 pub metric: Metric,
1221 pub period: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1222 pub stat: String,
1223 pub unit: String,
1224 }
1225
1226 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1227 #[serde(rename_all = "camelCase")]
1228 pub struct MetricsItem {
1229 pub consecutive_error_limit:
1230 k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1231 pub count: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1232 pub failure_condition: String,
1233 pub failure_limit: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1234 pub inconclusive_limit: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1235 pub initial_delay: String,
1236 pub interval: String,
1237 pub name: String,
1238 pub provider: Provider,
1239 pub success_condition: String,
1240 }
1241
1242 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1243 #[serde(rename_all = "camelCase")]
1244 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
1245 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
1246 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
1247 }
1248
1249 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1250 #[serde(rename_all = "camelCase")]
1251 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
1252 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
1253 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
1254 }
1255
1256 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1257 #[serde(rename_all = "camelCase")]
1258 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
1259 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
1260 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
1261 }
1262
1263 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1264 #[serde(rename_all = "camelCase")]
1265 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
1266 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
1267 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
1268 }
1269
1270 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1271 #[serde(rename_all = "camelCase")]
1272 pub struct NewRelic {
1273 pub profile: String,
1274 pub query: String,
1275 }
1276
1277 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1278 #[serde(rename_all = "camelCase")]
1279 pub struct NodeAffinity {
1280 pub preferred_during_scheduling_ignored_during_execution:
1281 Vec<NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
1282 pub required_during_scheduling_ignored_during_execution:
1283 RequiredDuringSchedulingIgnoredDuringExecution,
1284 }
1285
1286 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1287 #[serde(rename_all = "camelCase")]
1288 pub struct NodeSelector {
1289 pub properties: std::collections::HashMap<String, String>,
1290 }
1291
1292 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1293 #[serde(rename_all = "camelCase")]
1294 pub struct NodeSelectorTermsItem {
1295 pub match_expressions: Vec<NodeSelectorTermsItemMatchExpressionsItem>,
1296 pub match_fields: Vec<NodeSelectorTermsItemMatchFieldsItem>,
1297 }
1298
1299 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1300 #[serde(rename_all = "camelCase")]
1301 pub struct OptionsItem {
1302 pub name: String,
1303 pub value: String,
1304 }
1305
1306 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1307 #[serde(rename_all = "camelCase")]
1308 pub struct Os {
1309 pub name: String,
1310 }
1311
1312 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1313 #[serde(rename_all = "camelCase")]
1314 pub struct Overhead {
1315 pub properties: std::collections::HashMap<
1316 String,
1317 k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1318 >,
1319 }
1320
1321 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1322 #[serde(rename_all = "camelCase")]
1323 pub struct PodAffinity {
1324 pub preferred_during_scheduling_ignored_during_execution:
1325 Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
1326 pub required_during_scheduling_ignored_during_execution:
1327 Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
1328 }
1329
1330 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1331 #[serde(rename_all = "camelCase")]
1332 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
1333 pub label_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
1334 pub namespace_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
1335 pub namespaces: Vec<String>,
1336 pub topology_key: String,
1337 }
1338
1339 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1340 #[serde(rename_all = "camelCase")]
1341 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
1342 pub label_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
1343 pub namespace_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
1344 pub namespaces: Vec<String>,
1345 pub topology_key: String,
1346 }
1347
1348 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1349 #[serde(rename_all = "camelCase")]
1350 pub struct PodAntiAffinity {
1351 pub preferred_during_scheduling_ignored_during_execution:
1352 Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
1353 pub required_during_scheduling_ignored_during_execution:
1354 Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
1355 }
1356
1357 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1358 #[serde(rename_all = "camelCase")]
1359 pub struct ContainersItemPortsItem {
1360 pub container_port: i32,
1361 pub host_i_p: String,
1362 pub host_port: i32,
1363 pub name: String,
1364 pub protocol: String,
1365 }
1366
1367 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1368 #[serde(rename_all = "camelCase")]
1369 pub struct EphemeralContainersItemPortsItem {
1370 pub container_port: i32,
1371 pub host_i_p: String,
1372 pub host_port: i32,
1373 pub name: String,
1374 pub protocol: String,
1375 }
1376
1377 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1378 #[serde(rename_all = "camelCase")]
1379 pub struct InitContainersItemPortsItem {
1380 pub container_port: i32,
1381 pub host_i_p: String,
1382 pub host_port: i32,
1383 pub name: String,
1384 pub protocol: String,
1385 }
1386
1387 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1388 #[serde(rename_all = "camelCase")]
1389 pub struct ContainersItemLifecyclePostStart {
1390 pub exec: ContainersItemLifecyclePostStartExec,
1391 pub http_get: ContainersItemLifecyclePostStartHttpGet,
1392 pub tcp_socket: ContainersItemLifecyclePostStartTcpSocket,
1393 }
1394
1395 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1396 #[serde(rename_all = "camelCase")]
1397 pub struct EphemeralContainersItemLifecyclePostStart {
1398 pub exec: EphemeralContainersItemLifecyclePostStartExec,
1399 pub http_get: EphemeralContainersItemLifecyclePostStartHttpGet,
1400 pub tcp_socket: EphemeralContainersItemLifecyclePostStartTcpSocket,
1401 }
1402
1403 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1404 #[serde(rename_all = "camelCase")]
1405 pub struct InitContainersItemLifecyclePostStart {
1406 pub exec: InitContainersItemLifecyclePostStartExec,
1407 pub http_get: InitContainersItemLifecyclePostStartHttpGet,
1408 pub tcp_socket: InitContainersItemLifecyclePostStartTcpSocket,
1409 }
1410
1411 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1412 #[serde(rename_all = "camelCase")]
1413 pub struct ContainersItemLifecyclePreStop {
1414 pub exec: ContainersItemLifecyclePreStopExec,
1415 pub http_get: ContainersItemLifecyclePreStopHttpGet,
1416 pub tcp_socket: ContainersItemLifecyclePreStopTcpSocket,
1417 }
1418
1419 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1420 #[serde(rename_all = "camelCase")]
1421 pub struct EphemeralContainersItemLifecyclePreStop {
1422 pub exec: EphemeralContainersItemLifecyclePreStopExec,
1423 pub http_get: EphemeralContainersItemLifecyclePreStopHttpGet,
1424 pub tcp_socket: EphemeralContainersItemLifecyclePreStopTcpSocket,
1425 }
1426
1427 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1428 #[serde(rename_all = "camelCase")]
1429 pub struct InitContainersItemLifecyclePreStop {
1430 pub exec: InitContainersItemLifecyclePreStopExec,
1431 pub http_get: InitContainersItemLifecyclePreStopHttpGet,
1432 pub tcp_socket: InitContainersItemLifecyclePreStopTcpSocket,
1433 }
1434
1435 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1436 #[serde(rename_all = "camelCase")]
1437 pub struct Preference {
1438 pub match_expressions: Vec<PreferenceMatchExpressionsItem>,
1439 pub match_fields: Vec<PreferenceMatchFieldsItem>,
1440 }
1441
1442 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1443 #[serde(rename_all = "camelCase")]
1444 pub struct NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
1445 pub preference: Preference,
1446 pub weight: i32,
1447 }
1448
1449 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1450 #[serde(rename_all = "camelCase")]
1451 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
1452 pub pod_affinity_term:
1453 PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
1454 pub weight: i32,
1455 }
1456
1457 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1458 #[serde(rename_all = "camelCase")]
1459 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
1460 pub pod_affinity_term: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
1461 pub weight: i32,
1462 }
1463
1464 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1465 #[serde(rename_all = "camelCase")]
1466 pub struct Prometheus {
1467 pub address: String,
1468 pub query: String,
1469 }
1470
1471 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1472 #[serde(rename_all = "camelCase")]
1473 pub struct Provider {
1474 pub cloud_watch: CloudWatch,
1475 pub datadog: Datadog,
1476 pub graphite: Graphite,
1477 pub influxdb: Influxdb,
1478 pub job: Job,
1479 pub kayenta: Kayenta,
1480 pub new_relic: NewRelic,
1481 pub prometheus: Prometheus,
1482 pub wavefront: Wavefront,
1483 pub web: Web,
1484 }
1485
1486 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1487 #[serde(rename_all = "camelCase")]
1488 pub struct ReadinessGatesItem {
1489 pub condition_type: String,
1490 }
1491
1492 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1493 #[serde(rename_all = "camelCase")]
1494 pub struct ContainersItemReadinessProbe {
1495 pub exec: ContainersItemReadinessProbeExec,
1496 pub failure_threshold: i32,
1497 pub grpc: ContainersItemReadinessProbeGrpc,
1498 pub http_get: ContainersItemReadinessProbeHttpGet,
1499 pub initial_delay_seconds: i32,
1500 pub period_seconds: i32,
1501 pub success_threshold: i32,
1502 pub tcp_socket: ContainersItemReadinessProbeTcpSocket,
1503 pub termination_grace_period_seconds: i64,
1504 pub timeout_seconds: i32,
1505 }
1506
1507 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1508 #[serde(rename_all = "camelCase")]
1509 pub struct EphemeralContainersItemReadinessProbe {
1510 pub exec: EphemeralContainersItemReadinessProbeExec,
1511 pub failure_threshold: i32,
1512 pub grpc: EphemeralContainersItemReadinessProbeGrpc,
1513 pub http_get: EphemeralContainersItemReadinessProbeHttpGet,
1514 pub initial_delay_seconds: i32,
1515 pub period_seconds: i32,
1516 pub success_threshold: i32,
1517 pub tcp_socket: EphemeralContainersItemReadinessProbeTcpSocket,
1518 pub termination_grace_period_seconds: i64,
1519 pub timeout_seconds: i32,
1520 }
1521
1522 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1523 #[serde(rename_all = "camelCase")]
1524 pub struct InitContainersItemReadinessProbe {
1525 pub exec: InitContainersItemReadinessProbeExec,
1526 pub failure_threshold: i32,
1527 pub grpc: InitContainersItemReadinessProbeGrpc,
1528 pub http_get: InitContainersItemReadinessProbeHttpGet,
1529 pub initial_delay_seconds: i32,
1530 pub period_seconds: i32,
1531 pub success_threshold: i32,
1532 pub tcp_socket: InitContainersItemReadinessProbeTcpSocket,
1533 pub termination_grace_period_seconds: i64,
1534 pub timeout_seconds: i32,
1535 }
1536
1537 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1538 #[serde(rename_all = "camelCase")]
1539 pub struct RequiredDuringSchedulingIgnoredDuringExecution {
1540 pub node_selector_terms: Vec<NodeSelectorTermsItem>,
1541 }
1542
1543 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1544 #[serde(rename_all = "camelCase")]
1545 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
1546 pub label_selector:
1547 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
1548 pub namespace_selector:
1549 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
1550 pub namespaces: Vec<String>,
1551 pub topology_key: String,
1552 }
1553
1554 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1555 #[serde(rename_all = "camelCase")]
1556 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
1557 pub label_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
1558 pub namespace_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
1559 pub namespaces: Vec<String>,
1560 pub topology_key: String,
1561 }
1562
1563 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1564 #[serde(rename_all = "camelCase")]
1565 pub struct ContainersItemEnvItemValueFromResourceFieldRef {
1566 pub container_name: String,
1567 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1568 pub resource: String,
1569 }
1570
1571 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1572 #[serde(rename_all = "camelCase")]
1573 pub struct EphemeralContainersItemEnvItemValueFromResourceFieldRef {
1574 pub container_name: String,
1575 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1576 pub resource: String,
1577 }
1578
1579 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1580 #[serde(rename_all = "camelCase")]
1581 pub struct InitContainersItemEnvItemValueFromResourceFieldRef {
1582 pub container_name: String,
1583 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1584 pub resource: String,
1585 }
1586
1587 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1588 #[serde(rename_all = "camelCase")]
1589 pub struct ContainersItemResources {
1590 pub limits: serde_json::Map<String, serde_json::Value>,
1591 pub requests: serde_json::Map<String, serde_json::Value>,
1592 }
1593
1594 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1595 #[serde(rename_all = "camelCase")]
1596 pub struct EphemeralContainersItemResources {
1597 pub limits: serde_json::Map<String, serde_json::Value>,
1598 pub requests: serde_json::Map<String, serde_json::Value>,
1599 }
1600
1601 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1602 #[serde(rename_all = "camelCase")]
1603 pub struct InitContainersItemResources {
1604 pub limits: serde_json::Map<String, serde_json::Value>,
1605 pub requests: serde_json::Map<String, serde_json::Value>,
1606 }
1607
1608 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1609 #[serde(rename_all = "camelCase")]
1610 pub struct RunSummary {
1611 pub count: i32,
1612 pub error: i32,
1613 pub failed: i32,
1614 pub inconclusive: i32,
1615 pub successful: i32,
1616 }
1617
1618 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1619 #[serde(rename_all = "camelCase")]
1620 pub struct ScopesItem {
1621 pub control_scope: ControlScope,
1622 pub experiment_scope: ExperimentScope,
1623 pub name: String,
1624 }
1625
1626 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1627 #[serde(rename_all = "camelCase")]
1628 pub struct ContainersItemSecurityContextSeLinuxOptions {
1629 pub level: String,
1630 pub role: String,
1631 pub r#type: String,
1632 pub user: String,
1633 }
1634
1635 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1636 #[serde(rename_all = "camelCase")]
1637 pub struct EphemeralContainersItemSecurityContextSeLinuxOptions {
1638 pub level: String,
1639 pub role: String,
1640 pub r#type: String,
1641 pub user: String,
1642 }
1643
1644 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1645 #[serde(rename_all = "camelCase")]
1646 pub struct InitContainersItemSecurityContextSeLinuxOptions {
1647 pub level: String,
1648 pub role: String,
1649 pub r#type: String,
1650 pub user: String,
1651 }
1652
1653 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1654 #[serde(rename_all = "camelCase")]
1655 pub struct SpecSecurityContextSeLinuxOptions {
1656 pub level: String,
1657 pub role: String,
1658 pub r#type: String,
1659 pub user: String,
1660 }
1661
1662 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1663 #[serde(rename_all = "camelCase")]
1664 pub struct ContainersItemSecurityContextSeccompProfile {
1665 pub localhost_profile: String,
1666 pub r#type: String,
1667 }
1668
1669 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1670 #[serde(rename_all = "camelCase")]
1671 pub struct EphemeralContainersItemSecurityContextSeccompProfile {
1672 pub localhost_profile: String,
1673 pub r#type: String,
1674 }
1675
1676 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1677 #[serde(rename_all = "camelCase")]
1678 pub struct InitContainersItemSecurityContextSeccompProfile {
1679 pub localhost_profile: String,
1680 pub r#type: String,
1681 }
1682
1683 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1684 #[serde(rename_all = "camelCase")]
1685 pub struct SpecSecurityContextSeccompProfile {
1686 pub localhost_profile: String,
1687 pub r#type: String,
1688 }
1689
1690 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1691 #[serde(rename_all = "camelCase")]
1692 pub struct ArgsItemValueFromSecretKeyRef {
1693 pub key: String,
1694 pub name: String,
1695 }
1696
1697 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1698 #[serde(rename_all = "camelCase")]
1699 pub struct ContainersItemEnvItemValueFromSecretKeyRef {
1700 pub key: String,
1701 pub name: String,
1702 pub optional: bool,
1703 }
1704
1705 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1706 #[serde(rename_all = "camelCase")]
1707 pub struct EphemeralContainersItemEnvItemValueFromSecretKeyRef {
1708 pub key: String,
1709 pub name: String,
1710 pub optional: bool,
1711 }
1712
1713 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1714 #[serde(rename_all = "camelCase")]
1715 pub struct InitContainersItemEnvItemValueFromSecretKeyRef {
1716 pub key: String,
1717 pub name: String,
1718 pub optional: bool,
1719 }
1720
1721 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1722 #[serde(rename_all = "camelCase")]
1723 pub struct ContainersItemEnvFromItemSecretRef {
1724 pub name: String,
1725 pub optional: bool,
1726 }
1727
1728 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1729 #[serde(rename_all = "camelCase")]
1730 pub struct EphemeralContainersItemEnvFromItemSecretRef {
1731 pub name: String,
1732 pub optional: bool,
1733 }
1734
1735 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1736 #[serde(rename_all = "camelCase")]
1737 pub struct InitContainersItemEnvFromItemSecretRef {
1738 pub name: String,
1739 pub optional: bool,
1740 }
1741
1742 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1743 #[serde(rename_all = "camelCase")]
1744 pub struct SpecSecurityContext {
1745 pub fs_group: i64,
1746 pub fs_group_change_policy: String,
1747 pub run_as_group: i64,
1748 pub run_as_non_root: bool,
1749 pub run_as_user: i64,
1750 pub se_linux_options: SpecSecurityContextSeLinuxOptions,
1751 pub seccomp_profile: SpecSecurityContextSeccompProfile,
1752 pub supplemental_groups: Vec<i64>,
1753 pub sysctls: Vec<SysctlsItem>,
1754 pub windows_options: SpecSecurityContextWindowsOptions,
1755 }
1756
1757 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1758 #[serde(rename_all = "camelCase")]
1759 pub struct ContainersItemSecurityContext {
1760 pub allow_privilege_escalation: bool,
1761 pub capabilities: ContainersItemSecurityContextCapabilities,
1762 pub privileged: bool,
1763 pub proc_mount: String,
1764 pub read_only_root_filesystem: bool,
1765 pub run_as_group: i64,
1766 pub run_as_non_root: bool,
1767 pub run_as_user: i64,
1768 pub se_linux_options: ContainersItemSecurityContextSeLinuxOptions,
1769 pub seccomp_profile: ContainersItemSecurityContextSeccompProfile,
1770 pub windows_options: ContainersItemSecurityContextWindowsOptions,
1771 }
1772
1773 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1774 #[serde(rename_all = "camelCase")]
1775 pub struct EphemeralContainersItemSecurityContext {
1776 pub allow_privilege_escalation: bool,
1777 pub capabilities: EphemeralContainersItemSecurityContextCapabilities,
1778 pub privileged: bool,
1779 pub proc_mount: String,
1780 pub read_only_root_filesystem: bool,
1781 pub run_as_group: i64,
1782 pub run_as_non_root: bool,
1783 pub run_as_user: i64,
1784 pub se_linux_options: EphemeralContainersItemSecurityContextSeLinuxOptions,
1785 pub seccomp_profile: EphemeralContainersItemSecurityContextSeccompProfile,
1786 pub windows_options: EphemeralContainersItemSecurityContextWindowsOptions,
1787 }
1788
1789 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1790 #[serde(rename_all = "camelCase")]
1791 pub struct InitContainersItemSecurityContext {
1792 pub allow_privilege_escalation: bool,
1793 pub capabilities: InitContainersItemSecurityContextCapabilities,
1794 pub privileged: bool,
1795 pub proc_mount: String,
1796 pub read_only_root_filesystem: bool,
1797 pub run_as_group: i64,
1798 pub run_as_non_root: bool,
1799 pub run_as_user: i64,
1800 pub se_linux_options: InitContainersItemSecurityContextSeLinuxOptions,
1801 pub seccomp_profile: InitContainersItemSecurityContextSeccompProfile,
1802 pub windows_options: InitContainersItemSecurityContextWindowsOptions,
1803 }
1804
1805 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1806 #[serde(rename_all = "camelCase")]
1807 pub struct Selector {
1808 pub match_expressions: Vec<SelectorMatchExpressionsItem>,
1809 pub match_labels: SelectorMatchLabels,
1810 }
1811
1812 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1813 #[serde(rename_all = "camelCase")]
1814 pub struct Spec {
1815 pub args: Vec<ArgsItem>,
1816 pub dry_run: Vec<DryRunItem>,
1817 pub measurement_retention: Vec<MeasurementRetentionItem>,
1818 pub metrics: Vec<MetricsItem>,
1819 pub terminate: bool,
1820 }
1821
1822 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1823 #[serde(rename_all = "camelCase")]
1824 pub struct JobSpec {
1825 pub active_deadline_seconds: i64,
1826 pub backoff_limit: i32,
1827 pub completion_mode: String,
1828 pub completions: i32,
1829 pub manual_selector: bool,
1830 pub parallelism: i32,
1831 pub selector: Selector,
1832 pub suspend: bool,
1833 pub template: Template,
1834 pub ttl_seconds_after_finished: i32,
1835 }
1836
1837 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1838 #[serde(rename_all = "camelCase")]
1839 pub struct TemplateSpec {
1840 pub active_deadline_seconds: i64,
1841 pub affinity: Affinity,
1842 pub automount_service_account_token: bool,
1843 pub containers: Vec<ContainersItem>,
1844 pub dns_config: DnsConfig,
1845 pub dns_policy: String,
1846 pub enable_service_links: bool,
1847 pub ephemeral_containers: Vec<EphemeralContainersItem>,
1848 pub host_aliases: Vec<HostAliasesItem>,
1849 pub host_i_p_c: bool,
1850 pub host_network: bool,
1851 pub host_p_i_d: bool,
1852 pub hostname: String,
1853 pub image_pull_secrets: Vec<ImagePullSecretsItem>,
1854 pub init_containers: Vec<InitContainersItem>,
1855 pub node_name: String,
1856 pub node_selector: NodeSelector,
1857 pub os: Os,
1858 pub overhead: Overhead,
1859 pub preemption_policy: String,
1860 pub priority: i32,
1861 pub priority_class_name: String,
1862 pub readiness_gates: Vec<ReadinessGatesItem>,
1863 pub restart_policy: String,
1864 pub runtime_class_name: String,
1865 pub scheduler_name: String,
1866 pub security_context: SpecSecurityContext,
1867 pub service_account: String,
1868 pub service_account_name: String,
1869 pub set_hostname_as_f_q_d_n: bool,
1870 pub share_process_namespace: bool,
1871 pub subdomain: String,
1872 pub termination_grace_period_seconds: i64,
1873 pub tolerations: Vec<TolerationsItem>,
1874 pub topology_spread_constraints: Vec<TopologySpreadConstraintsItem>,
1875 pub volumes: serde_json::Map<String, serde_json::Value>,
1876 }
1877
1878 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1879 #[serde(rename_all = "camelCase")]
1880 pub struct ContainersItemStartupProbe {
1881 pub exec: ContainersItemStartupProbeExec,
1882 pub failure_threshold: i32,
1883 pub grpc: ContainersItemStartupProbeGrpc,
1884 pub http_get: ContainersItemStartupProbeHttpGet,
1885 pub initial_delay_seconds: i32,
1886 pub period_seconds: i32,
1887 pub success_threshold: i32,
1888 pub tcp_socket: ContainersItemStartupProbeTcpSocket,
1889 pub termination_grace_period_seconds: i64,
1890 pub timeout_seconds: i32,
1891 }
1892
1893 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1894 #[serde(rename_all = "camelCase")]
1895 pub struct EphemeralContainersItemStartupProbe {
1896 pub exec: EphemeralContainersItemStartupProbeExec,
1897 pub failure_threshold: i32,
1898 pub grpc: EphemeralContainersItemStartupProbeGrpc,
1899 pub http_get: EphemeralContainersItemStartupProbeHttpGet,
1900 pub initial_delay_seconds: i32,
1901 pub period_seconds: i32,
1902 pub success_threshold: i32,
1903 pub tcp_socket: EphemeralContainersItemStartupProbeTcpSocket,
1904 pub termination_grace_period_seconds: i64,
1905 pub timeout_seconds: i32,
1906 }
1907
1908 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1909 #[serde(rename_all = "camelCase")]
1910 pub struct InitContainersItemStartupProbe {
1911 pub exec: InitContainersItemStartupProbeExec,
1912 pub failure_threshold: i32,
1913 pub grpc: InitContainersItemStartupProbeGrpc,
1914 pub http_get: InitContainersItemStartupProbeHttpGet,
1915 pub initial_delay_seconds: i32,
1916 pub period_seconds: i32,
1917 pub success_threshold: i32,
1918 pub tcp_socket: InitContainersItemStartupProbeTcpSocket,
1919 pub termination_grace_period_seconds: i64,
1920 pub timeout_seconds: i32,
1921 }
1922
1923 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1924 #[serde(rename_all = "camelCase")]
1925 pub struct Status {
1926 pub dry_run_summary: DryRunSummary,
1927 pub message: String,
1928 pub metric_results: Vec<MetricResultsItem>,
1929 pub phase: String,
1930 pub run_summary: RunSummary,
1931 pub started_at: String,
1932 }
1933
1934 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1935 #[serde(rename_all = "camelCase")]
1936 pub struct SysctlsItem {
1937 pub name: String,
1938 pub value: String,
1939 }
1940
1941 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1942 #[serde(rename_all = "camelCase")]
1943 pub struct ContainersItemLifecyclePostStartTcpSocket {
1944 pub host: String,
1945 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1946 }
1947
1948 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1949 #[serde(rename_all = "camelCase")]
1950 pub struct ContainersItemLifecyclePreStopTcpSocket {
1951 pub host: String,
1952 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1953 }
1954
1955 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1956 #[serde(rename_all = "camelCase")]
1957 pub struct ContainersItemLivenessProbeTcpSocket {
1958 pub host: String,
1959 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1960 }
1961
1962 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1963 #[serde(rename_all = "camelCase")]
1964 pub struct ContainersItemReadinessProbeTcpSocket {
1965 pub host: String,
1966 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1967 }
1968
1969 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1970 #[serde(rename_all = "camelCase")]
1971 pub struct ContainersItemStartupProbeTcpSocket {
1972 pub host: String,
1973 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1974 }
1975
1976 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1977 #[serde(rename_all = "camelCase")]
1978 pub struct EphemeralContainersItemLifecyclePostStartTcpSocket {
1979 pub host: String,
1980 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1981 }
1982
1983 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1984 #[serde(rename_all = "camelCase")]
1985 pub struct EphemeralContainersItemLifecyclePreStopTcpSocket {
1986 pub host: String,
1987 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1988 }
1989
1990 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1991 #[serde(rename_all = "camelCase")]
1992 pub struct EphemeralContainersItemLivenessProbeTcpSocket {
1993 pub host: String,
1994 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
1995 }
1996
1997 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
1998 #[serde(rename_all = "camelCase")]
1999 pub struct EphemeralContainersItemReadinessProbeTcpSocket {
2000 pub host: String,
2001 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2002 }
2003
2004 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2005 #[serde(rename_all = "camelCase")]
2006 pub struct EphemeralContainersItemStartupProbeTcpSocket {
2007 pub host: String,
2008 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2009 }
2010
2011 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2012 #[serde(rename_all = "camelCase")]
2013 pub struct InitContainersItemLifecyclePostStartTcpSocket {
2014 pub host: String,
2015 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2016 }
2017
2018 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2019 #[serde(rename_all = "camelCase")]
2020 pub struct InitContainersItemLifecyclePreStopTcpSocket {
2021 pub host: String,
2022 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2023 }
2024
2025 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2026 #[serde(rename_all = "camelCase")]
2027 pub struct InitContainersItemLivenessProbeTcpSocket {
2028 pub host: String,
2029 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2030 }
2031
2032 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2033 #[serde(rename_all = "camelCase")]
2034 pub struct InitContainersItemReadinessProbeTcpSocket {
2035 pub host: String,
2036 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2037 }
2038
2039 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2040 #[serde(rename_all = "camelCase")]
2041 pub struct InitContainersItemStartupProbeTcpSocket {
2042 pub host: String,
2043 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2044 }
2045
2046 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2047 #[serde(rename_all = "camelCase")]
2048 pub struct Template {
2049 pub metadata: TemplateMetadata,
2050 pub spec: TemplateSpec,
2051 }
2052
2053 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2054 #[serde(rename_all = "camelCase")]
2055 pub struct Threshold {
2056 pub marginal: i64,
2057 pub pass: i64,
2058 }
2059
2060 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2061 #[serde(rename_all = "camelCase")]
2062 pub struct TolerationsItem {
2063 pub effect: String,
2064 pub key: String,
2065 pub operator: String,
2066 pub toleration_seconds: i64,
2067 pub value: String,
2068 }
2069
2070 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2071 #[serde(rename_all = "camelCase")]
2072 pub struct TopologySpreadConstraintsItem {
2073 pub label_selector: TopologySpreadConstraintsItemLabelSelector,
2074 pub max_skew: i32,
2075 pub topology_key: String,
2076 pub when_unsatisfiable: String,
2077 }
2078
2079 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2080 #[serde(rename_all = "camelCase")]
2081 pub struct ArgsItemValueFrom {
2082 pub field_ref: ArgsItemValueFromFieldRef,
2083 pub secret_key_ref: ArgsItemValueFromSecretKeyRef,
2084 }
2085
2086 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2087 #[serde(rename_all = "camelCase")]
2088 pub struct ContainersItemEnvItemValueFrom {
2089 pub config_map_key_ref: ContainersItemEnvItemValueFromConfigMapKeyRef,
2090 pub field_ref: ContainersItemEnvItemValueFromFieldRef,
2091 pub resource_field_ref: ContainersItemEnvItemValueFromResourceFieldRef,
2092 pub secret_key_ref: ContainersItemEnvItemValueFromSecretKeyRef,
2093 }
2094
2095 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2096 #[serde(rename_all = "camelCase")]
2097 pub struct EphemeralContainersItemEnvItemValueFrom {
2098 pub config_map_key_ref: EphemeralContainersItemEnvItemValueFromConfigMapKeyRef,
2099 pub field_ref: EphemeralContainersItemEnvItemValueFromFieldRef,
2100 pub resource_field_ref: EphemeralContainersItemEnvItemValueFromResourceFieldRef,
2101 pub secret_key_ref: EphemeralContainersItemEnvItemValueFromSecretKeyRef,
2102 }
2103
2104 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2105 #[serde(rename_all = "camelCase")]
2106 pub struct InitContainersItemEnvItemValueFrom {
2107 pub config_map_key_ref: InitContainersItemEnvItemValueFromConfigMapKeyRef,
2108 pub field_ref: InitContainersItemEnvItemValueFromFieldRef,
2109 pub resource_field_ref: InitContainersItemEnvItemValueFromResourceFieldRef,
2110 pub secret_key_ref: InitContainersItemEnvItemValueFromSecretKeyRef,
2111 }
2112
2113 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2114 #[serde(rename_all = "camelCase")]
2115 pub struct ContainersItemVolumeDevicesItem {
2116 pub device_path: String,
2117 pub name: String,
2118 }
2119
2120 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2121 #[serde(rename_all = "camelCase")]
2122 pub struct EphemeralContainersItemVolumeDevicesItem {
2123 pub device_path: String,
2124 pub name: String,
2125 }
2126
2127 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2128 #[serde(rename_all = "camelCase")]
2129 pub struct InitContainersItemVolumeDevicesItem {
2130 pub device_path: String,
2131 pub name: String,
2132 }
2133
2134 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2135 #[serde(rename_all = "camelCase")]
2136 pub struct ContainersItemVolumeMountsItem {
2137 pub mount_path: String,
2138 pub mount_propagation: String,
2139 pub name: String,
2140 pub read_only: bool,
2141 pub sub_path: String,
2142 pub sub_path_expr: String,
2143 }
2144
2145 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2146 #[serde(rename_all = "camelCase")]
2147 pub struct EphemeralContainersItemVolumeMountsItem {
2148 pub mount_path: String,
2149 pub mount_propagation: String,
2150 pub name: String,
2151 pub read_only: bool,
2152 pub sub_path: String,
2153 pub sub_path_expr: String,
2154 }
2155
2156 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2157 #[serde(rename_all = "camelCase")]
2158 pub struct InitContainersItemVolumeMountsItem {
2159 pub mount_path: String,
2160 pub mount_propagation: String,
2161 pub name: String,
2162 pub read_only: bool,
2163 pub sub_path: String,
2164 pub sub_path_expr: String,
2165 }
2166
2167 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2168 #[serde(rename_all = "camelCase")]
2169 pub struct Wavefront {
2170 pub address: String,
2171 pub query: String,
2172 }
2173
2174 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2175 #[serde(rename_all = "camelCase")]
2176 pub struct Web {
2177 pub body: String,
2178 pub headers: Vec<HeadersItem>,
2179 pub insecure: bool,
2180 pub json_path: String,
2181 pub method: String,
2182 pub timeout_seconds: i64,
2183 pub url: String,
2184 }
2185
2186 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2187 #[serde(rename_all = "camelCase")]
2188 pub struct ContainersItemSecurityContextWindowsOptions {
2189 pub gmsa_credential_spec: String,
2190 pub gmsa_credential_spec_name: String,
2191 pub host_process: bool,
2192 pub run_as_user_name: String,
2193 }
2194
2195 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2196 #[serde(rename_all = "camelCase")]
2197 pub struct EphemeralContainersItemSecurityContextWindowsOptions {
2198 pub gmsa_credential_spec: String,
2199 pub gmsa_credential_spec_name: String,
2200 pub host_process: bool,
2201 pub run_as_user_name: String,
2202 }
2203
2204 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2205 #[serde(rename_all = "camelCase")]
2206 pub struct InitContainersItemSecurityContextWindowsOptions {
2207 pub gmsa_credential_spec: String,
2208 pub gmsa_credential_spec_name: String,
2209 pub host_process: bool,
2210 pub run_as_user_name: String,
2211 }
2212
2213 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2214 #[serde(rename_all = "camelCase")]
2215 pub struct SpecSecurityContextWindowsOptions {
2216 pub gmsa_credential_spec: String,
2217 pub gmsa_credential_spec_name: String,
2218 pub host_process: bool,
2219 pub run_as_user_name: String,
2220 }
2221 }
2222 pub mod analysis_template {
2223 #[derive(serde::Deserialize, Debug, PartialEq)]
2224 pub struct AnalysisTemplate {
2225 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
2226 pub spec: Spec,
2227 }
2228
2229 impl k8s_openapi::Resource for AnalysisTemplate {
2230 type Scope = k8s_openapi::ClusterResourceScope;
2231
2232 const API_VERSION: &'static str = "argoproj.io/v1alpha1";
2233 const GROUP: &'static str = "argoproj.io";
2234 const KIND: &'static str = "AnalysisTemplate";
2235 const VERSION: &'static str = "v1alpha1";
2236 const URL_PATH_SEGMENT: &'static str = "TODO";
2237 }
2238
2239 impl k8s_openapi::Metadata for AnalysisTemplate {
2240 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
2241
2242 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
2243 &self.metadata
2244 }
2245
2246 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
2247 &mut self.metadata
2248 }
2249 }
2250
2251 impl serde::Serialize for AnalysisTemplate {
2252 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
2253 where
2254 S: serde::Serializer,
2255 {
2256 use serde::ser::SerializeStruct;
2257 let mut state = serializer.serialize_struct("AnalysisTemplate", 4)?;
2258 state.serialize_field(
2259 "apiVersion",
2260 <Self as k8s_openapi::Resource>::API_VERSION,
2261 )?;
2262 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
2263 state.serialize_field("metadata", &self.metadata)?;
2264 state.serialize_field("spec", &self.spec)?;
2265 state.end()
2266 }
2267 }
2268
2269 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2270 #[serde(rename_all = "camelCase")]
2271 pub struct Affinity {
2272 pub node_affinity: NodeAffinity,
2273 pub pod_affinity: PodAffinity,
2274 pub pod_anti_affinity: PodAntiAffinity,
2275 }
2276
2277 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2278 #[serde(rename_all = "camelCase")]
2279 pub struct JobMetadataAnnotations {
2280 pub properties: std::collections::HashMap<String, String>,
2281 }
2282
2283 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2284 #[serde(rename_all = "camelCase")]
2285 pub struct TemplateMetadataAnnotations {
2286 pub properties: std::collections::HashMap<String, String>,
2287 }
2288
2289 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2290 #[serde(rename_all = "camelCase")]
2291 pub struct ArgsItem {
2292 pub name: String,
2293 pub value: String,
2294 pub value_from: ArgsItemValueFrom,
2295 }
2296
2297 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2298 #[serde(rename_all = "camelCase")]
2299 pub struct ContainersItemSecurityContextCapabilities {
2300 pub add: Vec<String>,
2301 pub drop: Vec<String>,
2302 }
2303
2304 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2305 #[serde(rename_all = "camelCase")]
2306 pub struct EphemeralContainersItemSecurityContextCapabilities {
2307 pub add: Vec<String>,
2308 pub drop: Vec<String>,
2309 }
2310
2311 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2312 #[serde(rename_all = "camelCase")]
2313 pub struct InitContainersItemSecurityContextCapabilities {
2314 pub add: Vec<String>,
2315 pub drop: Vec<String>,
2316 }
2317
2318 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2319 #[serde(rename_all = "camelCase")]
2320 pub struct CloudWatch {
2321 pub interval: String,
2322 pub metric_data_queries: Vec<MetricDataQueriesItem>,
2323 }
2324
2325 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2326 #[serde(rename_all = "camelCase")]
2327 pub struct ContainersItemEnvItemValueFromConfigMapKeyRef {
2328 pub key: String,
2329 pub name: String,
2330 pub optional: bool,
2331 }
2332
2333 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2334 #[serde(rename_all = "camelCase")]
2335 pub struct EphemeralContainersItemEnvItemValueFromConfigMapKeyRef {
2336 pub key: String,
2337 pub name: String,
2338 pub optional: bool,
2339 }
2340
2341 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2342 #[serde(rename_all = "camelCase")]
2343 pub struct InitContainersItemEnvItemValueFromConfigMapKeyRef {
2344 pub key: String,
2345 pub name: String,
2346 pub optional: bool,
2347 }
2348
2349 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2350 #[serde(rename_all = "camelCase")]
2351 pub struct ContainersItemEnvFromItemConfigMapRef {
2352 pub name: String,
2353 pub optional: bool,
2354 }
2355
2356 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2357 #[serde(rename_all = "camelCase")]
2358 pub struct EphemeralContainersItemEnvFromItemConfigMapRef {
2359 pub name: String,
2360 pub optional: bool,
2361 }
2362
2363 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2364 #[serde(rename_all = "camelCase")]
2365 pub struct InitContainersItemEnvFromItemConfigMapRef {
2366 pub name: String,
2367 pub optional: bool,
2368 }
2369
2370 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2371 #[serde(rename_all = "camelCase")]
2372 pub struct ContainersItem {
2373 pub args: Vec<String>,
2374 pub command: Vec<String>,
2375 pub env: Vec<ContainersItemEnvItem>,
2376 pub env_from: Vec<ContainersItemEnvFromItem>,
2377 pub image: String,
2378 pub image_pull_policy: String,
2379 pub lifecycle: ContainersItemLifecycle,
2380 pub liveness_probe: ContainersItemLivenessProbe,
2381 pub name: String,
2382 pub ports: Vec<ContainersItemPortsItem>,
2383 pub readiness_probe: ContainersItemReadinessProbe,
2384 pub resources: ContainersItemResources,
2385 pub security_context: ContainersItemSecurityContext,
2386 pub startup_probe: ContainersItemStartupProbe,
2387 pub stdin: bool,
2388 pub stdin_once: bool,
2389 pub termination_message_path: String,
2390 pub termination_message_policy: String,
2391 pub tty: bool,
2392 pub volume_devices: Vec<ContainersItemVolumeDevicesItem>,
2393 pub volume_mounts: Vec<ContainersItemVolumeMountsItem>,
2394 pub working_dir: String,
2395 }
2396
2397 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2398 #[serde(rename_all = "camelCase")]
2399 pub struct ControlScope {
2400 pub end: String,
2401 pub region: String,
2402 pub scope: String,
2403 pub start: String,
2404 pub step: i64,
2405 }
2406
2407 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2408 #[serde(rename_all = "camelCase")]
2409 pub struct Datadog {
2410 pub interval: String,
2411 pub query: String,
2412 }
2413
2414 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2415 #[serde(rename_all = "camelCase")]
2416 pub struct DimensionsItem {
2417 pub name: String,
2418 pub value: String,
2419 }
2420
2421 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2422 #[serde(rename_all = "camelCase")]
2423 pub struct DnsConfig {
2424 pub nameservers: Vec<String>,
2425 pub options: Vec<OptionsItem>,
2426 pub searches: Vec<String>,
2427 }
2428
2429 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2430 #[serde(rename_all = "camelCase")]
2431 pub struct DryRunItem {
2432 pub metric_name: String,
2433 }
2434
2435 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2436 #[serde(rename_all = "camelCase")]
2437 pub struct ContainersItemEnvFromItem {
2438 pub config_map_ref: ContainersItemEnvFromItemConfigMapRef,
2439 pub prefix: String,
2440 pub secret_ref: ContainersItemEnvFromItemSecretRef,
2441 }
2442
2443 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2444 #[serde(rename_all = "camelCase")]
2445 pub struct EphemeralContainersItemEnvFromItem {
2446 pub config_map_ref: EphemeralContainersItemEnvFromItemConfigMapRef,
2447 pub prefix: String,
2448 pub secret_ref: EphemeralContainersItemEnvFromItemSecretRef,
2449 }
2450
2451 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2452 #[serde(rename_all = "camelCase")]
2453 pub struct InitContainersItemEnvFromItem {
2454 pub config_map_ref: InitContainersItemEnvFromItemConfigMapRef,
2455 pub prefix: String,
2456 pub secret_ref: InitContainersItemEnvFromItemSecretRef,
2457 }
2458
2459 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2460 #[serde(rename_all = "camelCase")]
2461 pub struct ContainersItemEnvItem {
2462 pub name: String,
2463 pub value: String,
2464 pub value_from: ContainersItemEnvItemValueFrom,
2465 }
2466
2467 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2468 #[serde(rename_all = "camelCase")]
2469 pub struct EphemeralContainersItemEnvItem {
2470 pub name: String,
2471 pub value: String,
2472 pub value_from: EphemeralContainersItemEnvItemValueFrom,
2473 }
2474
2475 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2476 #[serde(rename_all = "camelCase")]
2477 pub struct InitContainersItemEnvItem {
2478 pub name: String,
2479 pub value: String,
2480 pub value_from: InitContainersItemEnvItemValueFrom,
2481 }
2482
2483 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2484 #[serde(rename_all = "camelCase")]
2485 pub struct EphemeralContainersItem {
2486 pub args: Vec<String>,
2487 pub command: Vec<String>,
2488 pub env: Vec<EphemeralContainersItemEnvItem>,
2489 pub env_from: Vec<EphemeralContainersItemEnvFromItem>,
2490 pub image: String,
2491 pub image_pull_policy: String,
2492 pub lifecycle: EphemeralContainersItemLifecycle,
2493 pub liveness_probe: EphemeralContainersItemLivenessProbe,
2494 pub name: String,
2495 pub ports: Vec<EphemeralContainersItemPortsItem>,
2496 pub readiness_probe: EphemeralContainersItemReadinessProbe,
2497 pub resources: EphemeralContainersItemResources,
2498 pub security_context: EphemeralContainersItemSecurityContext,
2499 pub startup_probe: EphemeralContainersItemStartupProbe,
2500 pub stdin: bool,
2501 pub stdin_once: bool,
2502 pub target_container_name: String,
2503 pub termination_message_path: String,
2504 pub termination_message_policy: String,
2505 pub tty: bool,
2506 pub volume_devices: Vec<EphemeralContainersItemVolumeDevicesItem>,
2507 pub volume_mounts: Vec<EphemeralContainersItemVolumeMountsItem>,
2508 pub working_dir: String,
2509 }
2510
2511 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2512 #[serde(rename_all = "camelCase")]
2513 pub struct ContainersItemLifecyclePostStartExec {
2514 pub command: Vec<String>,
2515 }
2516
2517 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2518 #[serde(rename_all = "camelCase")]
2519 pub struct ContainersItemLifecyclePreStopExec {
2520 pub command: Vec<String>,
2521 }
2522
2523 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2524 #[serde(rename_all = "camelCase")]
2525 pub struct ContainersItemLivenessProbeExec {
2526 pub command: Vec<String>,
2527 }
2528
2529 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2530 #[serde(rename_all = "camelCase")]
2531 pub struct ContainersItemReadinessProbeExec {
2532 pub command: Vec<String>,
2533 }
2534
2535 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2536 #[serde(rename_all = "camelCase")]
2537 pub struct ContainersItemStartupProbeExec {
2538 pub command: Vec<String>,
2539 }
2540
2541 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2542 #[serde(rename_all = "camelCase")]
2543 pub struct EphemeralContainersItemLifecyclePostStartExec {
2544 pub command: Vec<String>,
2545 }
2546
2547 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2548 #[serde(rename_all = "camelCase")]
2549 pub struct EphemeralContainersItemLifecyclePreStopExec {
2550 pub command: Vec<String>,
2551 }
2552
2553 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2554 #[serde(rename_all = "camelCase")]
2555 pub struct EphemeralContainersItemLivenessProbeExec {
2556 pub command: Vec<String>,
2557 }
2558
2559 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2560 #[serde(rename_all = "camelCase")]
2561 pub struct EphemeralContainersItemReadinessProbeExec {
2562 pub command: Vec<String>,
2563 }
2564
2565 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2566 #[serde(rename_all = "camelCase")]
2567 pub struct EphemeralContainersItemStartupProbeExec {
2568 pub command: Vec<String>,
2569 }
2570
2571 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2572 #[serde(rename_all = "camelCase")]
2573 pub struct InitContainersItemLifecyclePostStartExec {
2574 pub command: Vec<String>,
2575 }
2576
2577 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2578 #[serde(rename_all = "camelCase")]
2579 pub struct InitContainersItemLifecyclePreStopExec {
2580 pub command: Vec<String>,
2581 }
2582
2583 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2584 #[serde(rename_all = "camelCase")]
2585 pub struct InitContainersItemLivenessProbeExec {
2586 pub command: Vec<String>,
2587 }
2588
2589 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2590 #[serde(rename_all = "camelCase")]
2591 pub struct InitContainersItemReadinessProbeExec {
2592 pub command: Vec<String>,
2593 }
2594
2595 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2596 #[serde(rename_all = "camelCase")]
2597 pub struct InitContainersItemStartupProbeExec {
2598 pub command: Vec<String>,
2599 }
2600
2601 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2602 #[serde(rename_all = "camelCase")]
2603 pub struct ExperimentScope {
2604 pub end: String,
2605 pub region: String,
2606 pub scope: String,
2607 pub start: String,
2608 pub step: i64,
2609 }
2610
2611 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2612 #[serde(rename_all = "camelCase")]
2613 pub struct ArgsItemValueFromFieldRef {
2614 pub field_path: String,
2615 }
2616
2617 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2618 #[serde(rename_all = "camelCase")]
2619 pub struct ContainersItemEnvItemValueFromFieldRef {
2620 pub api_version: String,
2621 pub field_path: String,
2622 }
2623
2624 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2625 #[serde(rename_all = "camelCase")]
2626 pub struct EphemeralContainersItemEnvItemValueFromFieldRef {
2627 pub api_version: String,
2628 pub field_path: String,
2629 }
2630
2631 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2632 #[serde(rename_all = "camelCase")]
2633 pub struct InitContainersItemEnvItemValueFromFieldRef {
2634 pub api_version: String,
2635 pub field_path: String,
2636 }
2637
2638 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2639 #[serde(rename_all = "camelCase")]
2640 pub struct Graphite {
2641 pub address: String,
2642 pub query: String,
2643 }
2644
2645 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2646 #[serde(rename_all = "camelCase")]
2647 pub struct ContainersItemLivenessProbeGrpc {
2648 pub port: i32,
2649 pub service: String,
2650 }
2651
2652 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2653 #[serde(rename_all = "camelCase")]
2654 pub struct ContainersItemReadinessProbeGrpc {
2655 pub port: i32,
2656 pub service: String,
2657 }
2658
2659 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2660 #[serde(rename_all = "camelCase")]
2661 pub struct ContainersItemStartupProbeGrpc {
2662 pub port: i32,
2663 pub service: String,
2664 }
2665
2666 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2667 #[serde(rename_all = "camelCase")]
2668 pub struct EphemeralContainersItemLivenessProbeGrpc {
2669 pub port: i32,
2670 pub service: String,
2671 }
2672
2673 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2674 #[serde(rename_all = "camelCase")]
2675 pub struct EphemeralContainersItemReadinessProbeGrpc {
2676 pub port: i32,
2677 pub service: String,
2678 }
2679
2680 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2681 #[serde(rename_all = "camelCase")]
2682 pub struct EphemeralContainersItemStartupProbeGrpc {
2683 pub port: i32,
2684 pub service: String,
2685 }
2686
2687 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2688 #[serde(rename_all = "camelCase")]
2689 pub struct InitContainersItemLivenessProbeGrpc {
2690 pub port: i32,
2691 pub service: String,
2692 }
2693
2694 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2695 #[serde(rename_all = "camelCase")]
2696 pub struct InitContainersItemReadinessProbeGrpc {
2697 pub port: i32,
2698 pub service: String,
2699 }
2700
2701 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2702 #[serde(rename_all = "camelCase")]
2703 pub struct InitContainersItemStartupProbeGrpc {
2704 pub port: i32,
2705 pub service: String,
2706 }
2707
2708 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2709 #[serde(rename_all = "camelCase")]
2710 pub struct HeadersItem {
2711 pub key: String,
2712 pub value: String,
2713 }
2714
2715 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2716 #[serde(rename_all = "camelCase")]
2717 pub struct HostAliasesItem {
2718 pub hostnames: Vec<String>,
2719 pub ip: String,
2720 }
2721
2722 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2723 #[serde(rename_all = "camelCase")]
2724 pub struct ContainersItemLifecyclePostStartHttpGet {
2725 pub host: String,
2726 pub http_headers: Vec<ContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
2727 pub path: String,
2728 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2729 pub scheme: String,
2730 }
2731
2732 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2733 #[serde(rename_all = "camelCase")]
2734 pub struct ContainersItemLifecyclePreStopHttpGet {
2735 pub host: String,
2736 pub http_headers: Vec<ContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
2737 pub path: String,
2738 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2739 pub scheme: String,
2740 }
2741
2742 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2743 #[serde(rename_all = "camelCase")]
2744 pub struct ContainersItemLivenessProbeHttpGet {
2745 pub host: String,
2746 pub http_headers: Vec<ContainersItemLivenessProbeHttpGetHttpHeadersItem>,
2747 pub path: String,
2748 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2749 pub scheme: String,
2750 }
2751
2752 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2753 #[serde(rename_all = "camelCase")]
2754 pub struct ContainersItemReadinessProbeHttpGet {
2755 pub host: String,
2756 pub http_headers: Vec<ContainersItemReadinessProbeHttpGetHttpHeadersItem>,
2757 pub path: String,
2758 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2759 pub scheme: String,
2760 }
2761
2762 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2763 #[serde(rename_all = "camelCase")]
2764 pub struct ContainersItemStartupProbeHttpGet {
2765 pub host: String,
2766 pub http_headers: Vec<ContainersItemStartupProbeHttpGetHttpHeadersItem>,
2767 pub path: String,
2768 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2769 pub scheme: String,
2770 }
2771
2772 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2773 #[serde(rename_all = "camelCase")]
2774 pub struct EphemeralContainersItemLifecyclePostStartHttpGet {
2775 pub host: String,
2776 pub http_headers:
2777 Vec<EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
2778 pub path: String,
2779 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2780 pub scheme: String,
2781 }
2782
2783 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2784 #[serde(rename_all = "camelCase")]
2785 pub struct EphemeralContainersItemLifecyclePreStopHttpGet {
2786 pub host: String,
2787 pub http_headers:
2788 Vec<EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
2789 pub path: String,
2790 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2791 pub scheme: String,
2792 }
2793
2794 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2795 #[serde(rename_all = "camelCase")]
2796 pub struct EphemeralContainersItemLivenessProbeHttpGet {
2797 pub host: String,
2798 pub http_headers: Vec<EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem>,
2799 pub path: String,
2800 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2801 pub scheme: String,
2802 }
2803
2804 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2805 #[serde(rename_all = "camelCase")]
2806 pub struct EphemeralContainersItemReadinessProbeHttpGet {
2807 pub host: String,
2808 pub http_headers: Vec<EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem>,
2809 pub path: String,
2810 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2811 pub scheme: String,
2812 }
2813
2814 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2815 #[serde(rename_all = "camelCase")]
2816 pub struct EphemeralContainersItemStartupProbeHttpGet {
2817 pub host: String,
2818 pub http_headers: Vec<EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem>,
2819 pub path: String,
2820 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2821 pub scheme: String,
2822 }
2823
2824 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2825 #[serde(rename_all = "camelCase")]
2826 pub struct InitContainersItemLifecyclePostStartHttpGet {
2827 pub host: String,
2828 pub http_headers: Vec<InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
2829 pub path: String,
2830 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2831 pub scheme: String,
2832 }
2833
2834 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2835 #[serde(rename_all = "camelCase")]
2836 pub struct InitContainersItemLifecyclePreStopHttpGet {
2837 pub host: String,
2838 pub http_headers: Vec<InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
2839 pub path: String,
2840 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2841 pub scheme: String,
2842 }
2843
2844 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2845 #[serde(rename_all = "camelCase")]
2846 pub struct InitContainersItemLivenessProbeHttpGet {
2847 pub host: String,
2848 pub http_headers: Vec<InitContainersItemLivenessProbeHttpGetHttpHeadersItem>,
2849 pub path: String,
2850 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2851 pub scheme: String,
2852 }
2853
2854 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2855 #[serde(rename_all = "camelCase")]
2856 pub struct InitContainersItemReadinessProbeHttpGet {
2857 pub host: String,
2858 pub http_headers: Vec<InitContainersItemReadinessProbeHttpGetHttpHeadersItem>,
2859 pub path: String,
2860 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2861 pub scheme: String,
2862 }
2863
2864 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2865 #[serde(rename_all = "camelCase")]
2866 pub struct InitContainersItemStartupProbeHttpGet {
2867 pub host: String,
2868 pub http_headers: Vec<InitContainersItemStartupProbeHttpGetHttpHeadersItem>,
2869 pub path: String,
2870 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
2871 pub scheme: String,
2872 }
2873
2874 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2875 #[serde(rename_all = "camelCase")]
2876 pub struct ContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
2877 pub name: String,
2878 pub value: String,
2879 }
2880
2881 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2882 #[serde(rename_all = "camelCase")]
2883 pub struct ContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
2884 pub name: String,
2885 pub value: String,
2886 }
2887
2888 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2889 #[serde(rename_all = "camelCase")]
2890 pub struct ContainersItemLivenessProbeHttpGetHttpHeadersItem {
2891 pub name: String,
2892 pub value: String,
2893 }
2894
2895 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2896 #[serde(rename_all = "camelCase")]
2897 pub struct ContainersItemReadinessProbeHttpGetHttpHeadersItem {
2898 pub name: String,
2899 pub value: String,
2900 }
2901
2902 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2903 #[serde(rename_all = "camelCase")]
2904 pub struct ContainersItemStartupProbeHttpGetHttpHeadersItem {
2905 pub name: String,
2906 pub value: String,
2907 }
2908
2909 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2910 #[serde(rename_all = "camelCase")]
2911 pub struct EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
2912 pub name: String,
2913 pub value: String,
2914 }
2915
2916 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2917 #[serde(rename_all = "camelCase")]
2918 pub struct EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
2919 pub name: String,
2920 pub value: String,
2921 }
2922
2923 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2924 #[serde(rename_all = "camelCase")]
2925 pub struct EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem {
2926 pub name: String,
2927 pub value: String,
2928 }
2929
2930 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2931 #[serde(rename_all = "camelCase")]
2932 pub struct EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem {
2933 pub name: String,
2934 pub value: String,
2935 }
2936
2937 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2938 #[serde(rename_all = "camelCase")]
2939 pub struct EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem {
2940 pub name: String,
2941 pub value: String,
2942 }
2943
2944 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2945 #[serde(rename_all = "camelCase")]
2946 pub struct InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
2947 pub name: String,
2948 pub value: String,
2949 }
2950
2951 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2952 #[serde(rename_all = "camelCase")]
2953 pub struct InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
2954 pub name: String,
2955 pub value: String,
2956 }
2957
2958 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2959 #[serde(rename_all = "camelCase")]
2960 pub struct InitContainersItemLivenessProbeHttpGetHttpHeadersItem {
2961 pub name: String,
2962 pub value: String,
2963 }
2964
2965 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2966 #[serde(rename_all = "camelCase")]
2967 pub struct InitContainersItemReadinessProbeHttpGetHttpHeadersItem {
2968 pub name: String,
2969 pub value: String,
2970 }
2971
2972 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2973 #[serde(rename_all = "camelCase")]
2974 pub struct InitContainersItemStartupProbeHttpGetHttpHeadersItem {
2975 pub name: String,
2976 pub value: String,
2977 }
2978
2979 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2980 #[serde(rename_all = "camelCase")]
2981 pub struct ImagePullSecretsItem {
2982 pub name: String,
2983 }
2984
2985 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2986 #[serde(rename_all = "camelCase")]
2987 pub struct Influxdb {
2988 pub profile: String,
2989 pub query: String,
2990 }
2991
2992 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
2993 #[serde(rename_all = "camelCase")]
2994 pub struct InitContainersItem {
2995 pub args: Vec<String>,
2996 pub command: Vec<String>,
2997 pub env: Vec<InitContainersItemEnvItem>,
2998 pub env_from: Vec<InitContainersItemEnvFromItem>,
2999 pub image: String,
3000 pub image_pull_policy: String,
3001 pub lifecycle: InitContainersItemLifecycle,
3002 pub liveness_probe: InitContainersItemLivenessProbe,
3003 pub name: String,
3004 pub ports: Vec<InitContainersItemPortsItem>,
3005 pub readiness_probe: InitContainersItemReadinessProbe,
3006 pub resources: InitContainersItemResources,
3007 pub security_context: InitContainersItemSecurityContext,
3008 pub startup_probe: InitContainersItemStartupProbe,
3009 pub stdin: bool,
3010 pub stdin_once: bool,
3011 pub termination_message_path: String,
3012 pub termination_message_policy: String,
3013 pub tty: bool,
3014 pub volume_devices: Vec<InitContainersItemVolumeDevicesItem>,
3015 pub volume_mounts: Vec<InitContainersItemVolumeMountsItem>,
3016 pub working_dir: String,
3017 }
3018
3019 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3020 #[serde(rename_all = "camelCase")]
3021 pub struct Job {
3022 pub metadata: JobMetadata,
3023 pub spec: JobSpec,
3024 }
3025
3026 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3027 #[serde(rename_all = "camelCase")]
3028 pub struct Kayenta {
3029 pub address: String,
3030 pub application: String,
3031 pub canary_config_name: String,
3032 pub configuration_account_name: String,
3033 pub metrics_account_name: String,
3034 pub scopes: Vec<ScopesItem>,
3035 pub storage_account_name: String,
3036 pub threshold: Threshold,
3037 }
3038
3039 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3040 #[serde(rename_all = "camelCase")]
3041 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
3042 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
3043 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
3044 }
3045
3046 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3047 #[serde(rename_all = "camelCase")]
3048 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
3049 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
3050 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
3051 }
3052
3053 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3054 #[serde(rename_all = "camelCase")]
3055 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
3056 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
3057 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
3058 }
3059
3060 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3061 #[serde(rename_all = "camelCase")]
3062 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
3063 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
3064 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
3065 }
3066
3067 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3068 #[serde(rename_all = "camelCase")]
3069 pub struct TopologySpreadConstraintsItemLabelSelector {
3070 pub match_expressions:
3071 Vec<TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem>,
3072 pub match_labels: TopologySpreadConstraintsItemLabelSelectorMatchLabels,
3073 }
3074
3075 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3076 #[serde(rename_all = "camelCase")]
3077 pub struct JobMetadataLabels {
3078 pub properties: std::collections::HashMap<String, String>,
3079 }
3080
3081 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3082 #[serde(rename_all = "camelCase")]
3083 pub struct TemplateMetadataLabels {
3084 pub properties: std::collections::HashMap<String, String>,
3085 }
3086
3087 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3088 #[serde(rename_all = "camelCase")]
3089 pub struct ContainersItemLifecycle {
3090 pub post_start: ContainersItemLifecyclePostStart,
3091 pub pre_stop: ContainersItemLifecyclePreStop,
3092 }
3093
3094 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3095 #[serde(rename_all = "camelCase")]
3096 pub struct EphemeralContainersItemLifecycle {
3097 pub post_start: EphemeralContainersItemLifecyclePostStart,
3098 pub pre_stop: EphemeralContainersItemLifecyclePreStop,
3099 }
3100
3101 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3102 #[serde(rename_all = "camelCase")]
3103 pub struct InitContainersItemLifecycle {
3104 pub post_start: InitContainersItemLifecyclePostStart,
3105 pub pre_stop: InitContainersItemLifecyclePreStop,
3106 }
3107
3108 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3109 #[serde(rename_all = "camelCase")]
3110 pub struct ContainersItemLivenessProbe {
3111 pub exec: ContainersItemLivenessProbeExec,
3112 pub failure_threshold: i32,
3113 pub grpc: ContainersItemLivenessProbeGrpc,
3114 pub http_get: ContainersItemLivenessProbeHttpGet,
3115 pub initial_delay_seconds: i32,
3116 pub period_seconds: i32,
3117 pub success_threshold: i32,
3118 pub tcp_socket: ContainersItemLivenessProbeTcpSocket,
3119 pub termination_grace_period_seconds: i64,
3120 pub timeout_seconds: i32,
3121 }
3122
3123 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3124 #[serde(rename_all = "camelCase")]
3125 pub struct EphemeralContainersItemLivenessProbe {
3126 pub exec: EphemeralContainersItemLivenessProbeExec,
3127 pub failure_threshold: i32,
3128 pub grpc: EphemeralContainersItemLivenessProbeGrpc,
3129 pub http_get: EphemeralContainersItemLivenessProbeHttpGet,
3130 pub initial_delay_seconds: i32,
3131 pub period_seconds: i32,
3132 pub success_threshold: i32,
3133 pub tcp_socket: EphemeralContainersItemLivenessProbeTcpSocket,
3134 pub termination_grace_period_seconds: i64,
3135 pub timeout_seconds: i32,
3136 }
3137
3138 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3139 #[serde(rename_all = "camelCase")]
3140 pub struct InitContainersItemLivenessProbe {
3141 pub exec: InitContainersItemLivenessProbeExec,
3142 pub failure_threshold: i32,
3143 pub grpc: InitContainersItemLivenessProbeGrpc,
3144 pub http_get: InitContainersItemLivenessProbeHttpGet,
3145 pub initial_delay_seconds: i32,
3146 pub period_seconds: i32,
3147 pub success_threshold: i32,
3148 pub tcp_socket: InitContainersItemLivenessProbeTcpSocket,
3149 pub termination_grace_period_seconds: i64,
3150 pub timeout_seconds: i32,
3151 }
3152
3153 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3154 #[serde(rename_all = "camelCase")]
3155 pub struct SelectorMatchExpressionsItem {
3156 pub key: String,
3157 pub operator: String,
3158 pub values: Vec<String>,
3159 }
3160
3161 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3162 #[serde(rename_all = "camelCase")]
3163 pub struct PreferenceMatchExpressionsItem {
3164 pub key: String,
3165 pub operator: String,
3166 pub values: Vec<String>,
3167 }
3168
3169 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3170 #[serde(rename_all = "camelCase")]
3171 pub struct NodeSelectorTermsItemMatchExpressionsItem {
3172 pub key: String,
3173 pub operator: String,
3174 pub values: Vec<String>,
3175 }
3176
3177 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3178 #[serde(rename_all = "camelCase")]
3179 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
3180 {
3181 pub key: String,
3182 pub operator: String,
3183 pub values: Vec<String>,
3184 }
3185
3186 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3187 #[serde(rename_all = "camelCase")]
3188 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
3189 {
3190 pub key: String,
3191 pub operator: String,
3192 pub values: Vec<String>,
3193 }
3194
3195 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3196 #[serde(rename_all = "camelCase")]
3197 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
3198 {
3199 pub key: String,
3200 pub operator: String,
3201 pub values: Vec<String>,
3202 }
3203
3204 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3205 #[serde(rename_all = "camelCase")]
3206 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
3207 {
3208 pub key: String,
3209 pub operator: String,
3210 pub values: Vec<String>,
3211 }
3212
3213 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3214 #[serde(rename_all = "camelCase")]
3215 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
3216 {
3217 pub key: String,
3218 pub operator: String,
3219 pub values: Vec<String>,
3220 }
3221
3222 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3223 #[serde(rename_all = "camelCase")]
3224 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
3225 {
3226 pub key: String,
3227 pub operator: String,
3228 pub values: Vec<String>,
3229 }
3230
3231 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3232 #[serde(rename_all = "camelCase")]
3233 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
3234 {
3235 pub key: String,
3236 pub operator: String,
3237 pub values: Vec<String>,
3238 }
3239
3240 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3241 #[serde(rename_all = "camelCase")]
3242 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
3243 {
3244 pub key: String,
3245 pub operator: String,
3246 pub values: Vec<String>,
3247 }
3248
3249 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3250 #[serde(rename_all = "camelCase")]
3251 pub struct TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem {
3252 pub key: String,
3253 pub operator: String,
3254 pub values: Vec<String>,
3255 }
3256
3257 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3258 #[serde(rename_all = "camelCase")]
3259 pub struct PreferenceMatchFieldsItem {
3260 pub key: String,
3261 pub operator: String,
3262 pub values: Vec<String>,
3263 }
3264
3265 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3266 #[serde(rename_all = "camelCase")]
3267 pub struct NodeSelectorTermsItemMatchFieldsItem {
3268 pub key: String,
3269 pub operator: String,
3270 pub values: Vec<String>,
3271 }
3272
3273 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3274 #[serde(rename_all = "camelCase")]
3275 pub struct SelectorMatchLabels {
3276 pub properties: std::collections::HashMap<String, String>,
3277 }
3278
3279 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3280 #[serde(rename_all = "camelCase")]
3281 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
3282 {
3283 pub properties: std::collections::HashMap<String, String>,
3284 }
3285
3286 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3287 #[serde(rename_all = "camelCase")]
3288 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
3289 {
3290 pub properties: std::collections::HashMap<String, String>,
3291 }
3292
3293 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3294 #[serde(rename_all = "camelCase")]
3295 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels {
3296 pub properties: std::collections::HashMap<String, String>,
3297 }
3298
3299 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3300 #[serde(rename_all = "camelCase")]
3301 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
3302 {
3303 pub properties: std::collections::HashMap<String, String>,
3304 }
3305
3306 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3307 #[serde(rename_all = "camelCase")]
3308 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
3309 {
3310 pub properties: std::collections::HashMap<String, String>,
3311 }
3312
3313 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3314 #[serde(rename_all = "camelCase")]
3315 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
3316 {
3317 pub properties: std::collections::HashMap<String, String>,
3318 }
3319
3320 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3321 #[serde(rename_all = "camelCase")]
3322 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels
3323 {
3324 pub properties: std::collections::HashMap<String, String>,
3325 }
3326
3327 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3328 #[serde(rename_all = "camelCase")]
3329 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
3330 {
3331 pub properties: std::collections::HashMap<String, String>,
3332 }
3333
3334 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3335 #[serde(rename_all = "camelCase")]
3336 pub struct TopologySpreadConstraintsItemLabelSelectorMatchLabels {
3337 pub properties: std::collections::HashMap<String, String>,
3338 }
3339
3340 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3341 #[serde(rename_all = "camelCase")]
3342 pub struct MeasurementRetentionItem {
3343 pub limit: i32,
3344 pub metric_name: String,
3345 }
3346
3347 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3348 #[serde(rename_all = "camelCase")]
3349 pub struct JobMetadata {
3350 pub annotations: JobMetadataAnnotations,
3351 pub labels: JobMetadataLabels,
3352 }
3353
3354 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3355 #[serde(rename_all = "camelCase")]
3356 pub struct TemplateMetadata {
3357 pub annotations: TemplateMetadataAnnotations,
3358 pub labels: TemplateMetadataLabels,
3359 }
3360
3361 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3362 #[serde(rename_all = "camelCase")]
3363 pub struct Metric {
3364 pub dimensions: Vec<DimensionsItem>,
3365 pub metric_name: String,
3366 pub namespace: String,
3367 }
3368
3369 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3370 #[serde(rename_all = "camelCase")]
3371 pub struct MetricDataQueriesItem {
3372 pub expression: String,
3373 pub id: String,
3374 pub label: String,
3375 pub metric_stat: MetricStat,
3376 pub period: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3377 pub return_data: bool,
3378 }
3379
3380 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3381 #[serde(rename_all = "camelCase")]
3382 pub struct MetricStat {
3383 pub metric: Metric,
3384 pub period: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3385 pub stat: String,
3386 pub unit: String,
3387 }
3388
3389 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3390 #[serde(rename_all = "camelCase")]
3391 pub struct MetricsItem {
3392 pub consecutive_error_limit:
3393 k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3394 pub count: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3395 pub failure_condition: String,
3396 pub failure_limit: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3397 pub inconclusive_limit: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3398 pub initial_delay: String,
3399 pub interval: String,
3400 pub name: String,
3401 pub provider: Provider,
3402 pub success_condition: String,
3403 }
3404
3405 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3406 #[serde(rename_all = "camelCase")]
3407 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
3408 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
3409 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
3410 }
3411
3412 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3413 #[serde(rename_all = "camelCase")]
3414 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
3415 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
3416 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
3417 }
3418
3419 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3420 #[serde(rename_all = "camelCase")]
3421 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
3422 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
3423 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
3424 }
3425
3426 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3427 #[serde(rename_all = "camelCase")]
3428 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
3429 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
3430 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
3431 }
3432
3433 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3434 #[serde(rename_all = "camelCase")]
3435 pub struct NewRelic {
3436 pub profile: String,
3437 pub query: String,
3438 }
3439
3440 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3441 #[serde(rename_all = "camelCase")]
3442 pub struct NodeAffinity {
3443 pub preferred_during_scheduling_ignored_during_execution:
3444 Vec<NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
3445 pub required_during_scheduling_ignored_during_execution:
3446 RequiredDuringSchedulingIgnoredDuringExecution,
3447 }
3448
3449 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3450 #[serde(rename_all = "camelCase")]
3451 pub struct NodeSelector {
3452 pub properties: std::collections::HashMap<String, String>,
3453 }
3454
3455 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3456 #[serde(rename_all = "camelCase")]
3457 pub struct NodeSelectorTermsItem {
3458 pub match_expressions: Vec<NodeSelectorTermsItemMatchExpressionsItem>,
3459 pub match_fields: Vec<NodeSelectorTermsItemMatchFieldsItem>,
3460 }
3461
3462 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3463 #[serde(rename_all = "camelCase")]
3464 pub struct OptionsItem {
3465 pub name: String,
3466 pub value: String,
3467 }
3468
3469 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3470 #[serde(rename_all = "camelCase")]
3471 pub struct Os {
3472 pub name: String,
3473 }
3474
3475 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3476 #[serde(rename_all = "camelCase")]
3477 pub struct Overhead {
3478 pub properties: std::collections::HashMap<
3479 String,
3480 k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3481 >,
3482 }
3483
3484 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3485 #[serde(rename_all = "camelCase")]
3486 pub struct PodAffinity {
3487 pub preferred_during_scheduling_ignored_during_execution:
3488 Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
3489 pub required_during_scheduling_ignored_during_execution:
3490 Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
3491 }
3492
3493 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3494 #[serde(rename_all = "camelCase")]
3495 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
3496 pub label_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
3497 pub namespace_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
3498 pub namespaces: Vec<String>,
3499 pub topology_key: String,
3500 }
3501
3502 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3503 #[serde(rename_all = "camelCase")]
3504 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
3505 pub label_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
3506 pub namespace_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
3507 pub namespaces: Vec<String>,
3508 pub topology_key: String,
3509 }
3510
3511 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3512 #[serde(rename_all = "camelCase")]
3513 pub struct PodAntiAffinity {
3514 pub preferred_during_scheduling_ignored_during_execution:
3515 Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
3516 pub required_during_scheduling_ignored_during_execution:
3517 Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
3518 }
3519
3520 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3521 #[serde(rename_all = "camelCase")]
3522 pub struct ContainersItemPortsItem {
3523 pub container_port: i32,
3524 pub host_i_p: String,
3525 pub host_port: i32,
3526 pub name: String,
3527 pub protocol: String,
3528 }
3529
3530 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3531 #[serde(rename_all = "camelCase")]
3532 pub struct EphemeralContainersItemPortsItem {
3533 pub container_port: i32,
3534 pub host_i_p: String,
3535 pub host_port: i32,
3536 pub name: String,
3537 pub protocol: String,
3538 }
3539
3540 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3541 #[serde(rename_all = "camelCase")]
3542 pub struct InitContainersItemPortsItem {
3543 pub container_port: i32,
3544 pub host_i_p: String,
3545 pub host_port: i32,
3546 pub name: String,
3547 pub protocol: String,
3548 }
3549
3550 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3551 #[serde(rename_all = "camelCase")]
3552 pub struct ContainersItemLifecyclePostStart {
3553 pub exec: ContainersItemLifecyclePostStartExec,
3554 pub http_get: ContainersItemLifecyclePostStartHttpGet,
3555 pub tcp_socket: ContainersItemLifecyclePostStartTcpSocket,
3556 }
3557
3558 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3559 #[serde(rename_all = "camelCase")]
3560 pub struct EphemeralContainersItemLifecyclePostStart {
3561 pub exec: EphemeralContainersItemLifecyclePostStartExec,
3562 pub http_get: EphemeralContainersItemLifecyclePostStartHttpGet,
3563 pub tcp_socket: EphemeralContainersItemLifecyclePostStartTcpSocket,
3564 }
3565
3566 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3567 #[serde(rename_all = "camelCase")]
3568 pub struct InitContainersItemLifecyclePostStart {
3569 pub exec: InitContainersItemLifecyclePostStartExec,
3570 pub http_get: InitContainersItemLifecyclePostStartHttpGet,
3571 pub tcp_socket: InitContainersItemLifecyclePostStartTcpSocket,
3572 }
3573
3574 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3575 #[serde(rename_all = "camelCase")]
3576 pub struct ContainersItemLifecyclePreStop {
3577 pub exec: ContainersItemLifecyclePreStopExec,
3578 pub http_get: ContainersItemLifecyclePreStopHttpGet,
3579 pub tcp_socket: ContainersItemLifecyclePreStopTcpSocket,
3580 }
3581
3582 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3583 #[serde(rename_all = "camelCase")]
3584 pub struct EphemeralContainersItemLifecyclePreStop {
3585 pub exec: EphemeralContainersItemLifecyclePreStopExec,
3586 pub http_get: EphemeralContainersItemLifecyclePreStopHttpGet,
3587 pub tcp_socket: EphemeralContainersItemLifecyclePreStopTcpSocket,
3588 }
3589
3590 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3591 #[serde(rename_all = "camelCase")]
3592 pub struct InitContainersItemLifecyclePreStop {
3593 pub exec: InitContainersItemLifecyclePreStopExec,
3594 pub http_get: InitContainersItemLifecyclePreStopHttpGet,
3595 pub tcp_socket: InitContainersItemLifecyclePreStopTcpSocket,
3596 }
3597
3598 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3599 #[serde(rename_all = "camelCase")]
3600 pub struct Preference {
3601 pub match_expressions: Vec<PreferenceMatchExpressionsItem>,
3602 pub match_fields: Vec<PreferenceMatchFieldsItem>,
3603 }
3604
3605 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3606 #[serde(rename_all = "camelCase")]
3607 pub struct NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
3608 pub preference: Preference,
3609 pub weight: i32,
3610 }
3611
3612 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3613 #[serde(rename_all = "camelCase")]
3614 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
3615 pub pod_affinity_term:
3616 PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
3617 pub weight: i32,
3618 }
3619
3620 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3621 #[serde(rename_all = "camelCase")]
3622 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
3623 pub pod_affinity_term: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
3624 pub weight: i32,
3625 }
3626
3627 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3628 #[serde(rename_all = "camelCase")]
3629 pub struct Prometheus {
3630 pub address: String,
3631 pub query: String,
3632 }
3633
3634 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3635 #[serde(rename_all = "camelCase")]
3636 pub struct Provider {
3637 pub cloud_watch: CloudWatch,
3638 pub datadog: Datadog,
3639 pub graphite: Graphite,
3640 pub influxdb: Influxdb,
3641 pub job: Job,
3642 pub kayenta: Kayenta,
3643 pub new_relic: NewRelic,
3644 pub prometheus: Prometheus,
3645 pub wavefront: Wavefront,
3646 pub web: Web,
3647 }
3648
3649 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3650 #[serde(rename_all = "camelCase")]
3651 pub struct ReadinessGatesItem {
3652 pub condition_type: String,
3653 }
3654
3655 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3656 #[serde(rename_all = "camelCase")]
3657 pub struct ContainersItemReadinessProbe {
3658 pub exec: ContainersItemReadinessProbeExec,
3659 pub failure_threshold: i32,
3660 pub grpc: ContainersItemReadinessProbeGrpc,
3661 pub http_get: ContainersItemReadinessProbeHttpGet,
3662 pub initial_delay_seconds: i32,
3663 pub period_seconds: i32,
3664 pub success_threshold: i32,
3665 pub tcp_socket: ContainersItemReadinessProbeTcpSocket,
3666 pub termination_grace_period_seconds: i64,
3667 pub timeout_seconds: i32,
3668 }
3669
3670 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3671 #[serde(rename_all = "camelCase")]
3672 pub struct EphemeralContainersItemReadinessProbe {
3673 pub exec: EphemeralContainersItemReadinessProbeExec,
3674 pub failure_threshold: i32,
3675 pub grpc: EphemeralContainersItemReadinessProbeGrpc,
3676 pub http_get: EphemeralContainersItemReadinessProbeHttpGet,
3677 pub initial_delay_seconds: i32,
3678 pub period_seconds: i32,
3679 pub success_threshold: i32,
3680 pub tcp_socket: EphemeralContainersItemReadinessProbeTcpSocket,
3681 pub termination_grace_period_seconds: i64,
3682 pub timeout_seconds: i32,
3683 }
3684
3685 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3686 #[serde(rename_all = "camelCase")]
3687 pub struct InitContainersItemReadinessProbe {
3688 pub exec: InitContainersItemReadinessProbeExec,
3689 pub failure_threshold: i32,
3690 pub grpc: InitContainersItemReadinessProbeGrpc,
3691 pub http_get: InitContainersItemReadinessProbeHttpGet,
3692 pub initial_delay_seconds: i32,
3693 pub period_seconds: i32,
3694 pub success_threshold: i32,
3695 pub tcp_socket: InitContainersItemReadinessProbeTcpSocket,
3696 pub termination_grace_period_seconds: i64,
3697 pub timeout_seconds: i32,
3698 }
3699
3700 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3701 #[serde(rename_all = "camelCase")]
3702 pub struct RequiredDuringSchedulingIgnoredDuringExecution {
3703 pub node_selector_terms: Vec<NodeSelectorTermsItem>,
3704 }
3705
3706 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3707 #[serde(rename_all = "camelCase")]
3708 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
3709 pub label_selector:
3710 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
3711 pub namespace_selector:
3712 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
3713 pub namespaces: Vec<String>,
3714 pub topology_key: String,
3715 }
3716
3717 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3718 #[serde(rename_all = "camelCase")]
3719 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
3720 pub label_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
3721 pub namespace_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
3722 pub namespaces: Vec<String>,
3723 pub topology_key: String,
3724 }
3725
3726 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3727 #[serde(rename_all = "camelCase")]
3728 pub struct ContainersItemEnvItemValueFromResourceFieldRef {
3729 pub container_name: String,
3730 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3731 pub resource: String,
3732 }
3733
3734 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3735 #[serde(rename_all = "camelCase")]
3736 pub struct EphemeralContainersItemEnvItemValueFromResourceFieldRef {
3737 pub container_name: String,
3738 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3739 pub resource: String,
3740 }
3741
3742 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3743 #[serde(rename_all = "camelCase")]
3744 pub struct InitContainersItemEnvItemValueFromResourceFieldRef {
3745 pub container_name: String,
3746 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
3747 pub resource: String,
3748 }
3749
3750 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3751 #[serde(rename_all = "camelCase")]
3752 pub struct ContainersItemResources {
3753 pub limits: serde_json::Map<String, serde_json::Value>,
3754 pub requests: serde_json::Map<String, serde_json::Value>,
3755 }
3756
3757 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3758 #[serde(rename_all = "camelCase")]
3759 pub struct EphemeralContainersItemResources {
3760 pub limits: serde_json::Map<String, serde_json::Value>,
3761 pub requests: serde_json::Map<String, serde_json::Value>,
3762 }
3763
3764 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3765 #[serde(rename_all = "camelCase")]
3766 pub struct InitContainersItemResources {
3767 pub limits: serde_json::Map<String, serde_json::Value>,
3768 pub requests: serde_json::Map<String, serde_json::Value>,
3769 }
3770
3771 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3772 #[serde(rename_all = "camelCase")]
3773 pub struct ScopesItem {
3774 pub control_scope: ControlScope,
3775 pub experiment_scope: ExperimentScope,
3776 pub name: String,
3777 }
3778
3779 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3780 #[serde(rename_all = "camelCase")]
3781 pub struct ContainersItemSecurityContextSeLinuxOptions {
3782 pub level: String,
3783 pub role: String,
3784 pub r#type: String,
3785 pub user: String,
3786 }
3787
3788 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3789 #[serde(rename_all = "camelCase")]
3790 pub struct EphemeralContainersItemSecurityContextSeLinuxOptions {
3791 pub level: String,
3792 pub role: String,
3793 pub r#type: String,
3794 pub user: String,
3795 }
3796
3797 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3798 #[serde(rename_all = "camelCase")]
3799 pub struct InitContainersItemSecurityContextSeLinuxOptions {
3800 pub level: String,
3801 pub role: String,
3802 pub r#type: String,
3803 pub user: String,
3804 }
3805
3806 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3807 #[serde(rename_all = "camelCase")]
3808 pub struct SpecSecurityContextSeLinuxOptions {
3809 pub level: String,
3810 pub role: String,
3811 pub r#type: String,
3812 pub user: String,
3813 }
3814
3815 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3816 #[serde(rename_all = "camelCase")]
3817 pub struct ContainersItemSecurityContextSeccompProfile {
3818 pub localhost_profile: String,
3819 pub r#type: String,
3820 }
3821
3822 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3823 #[serde(rename_all = "camelCase")]
3824 pub struct EphemeralContainersItemSecurityContextSeccompProfile {
3825 pub localhost_profile: String,
3826 pub r#type: String,
3827 }
3828
3829 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3830 #[serde(rename_all = "camelCase")]
3831 pub struct InitContainersItemSecurityContextSeccompProfile {
3832 pub localhost_profile: String,
3833 pub r#type: String,
3834 }
3835
3836 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3837 #[serde(rename_all = "camelCase")]
3838 pub struct SpecSecurityContextSeccompProfile {
3839 pub localhost_profile: String,
3840 pub r#type: String,
3841 }
3842
3843 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3844 #[serde(rename_all = "camelCase")]
3845 pub struct ArgsItemValueFromSecretKeyRef {
3846 pub key: String,
3847 pub name: String,
3848 }
3849
3850 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3851 #[serde(rename_all = "camelCase")]
3852 pub struct ContainersItemEnvItemValueFromSecretKeyRef {
3853 pub key: String,
3854 pub name: String,
3855 pub optional: bool,
3856 }
3857
3858 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3859 #[serde(rename_all = "camelCase")]
3860 pub struct EphemeralContainersItemEnvItemValueFromSecretKeyRef {
3861 pub key: String,
3862 pub name: String,
3863 pub optional: bool,
3864 }
3865
3866 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3867 #[serde(rename_all = "camelCase")]
3868 pub struct InitContainersItemEnvItemValueFromSecretKeyRef {
3869 pub key: String,
3870 pub name: String,
3871 pub optional: bool,
3872 }
3873
3874 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3875 #[serde(rename_all = "camelCase")]
3876 pub struct ContainersItemEnvFromItemSecretRef {
3877 pub name: String,
3878 pub optional: bool,
3879 }
3880
3881 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3882 #[serde(rename_all = "camelCase")]
3883 pub struct EphemeralContainersItemEnvFromItemSecretRef {
3884 pub name: String,
3885 pub optional: bool,
3886 }
3887
3888 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3889 #[serde(rename_all = "camelCase")]
3890 pub struct InitContainersItemEnvFromItemSecretRef {
3891 pub name: String,
3892 pub optional: bool,
3893 }
3894
3895 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3896 #[serde(rename_all = "camelCase")]
3897 pub struct SpecSecurityContext {
3898 pub fs_group: i64,
3899 pub fs_group_change_policy: String,
3900 pub run_as_group: i64,
3901 pub run_as_non_root: bool,
3902 pub run_as_user: i64,
3903 pub se_linux_options: SpecSecurityContextSeLinuxOptions,
3904 pub seccomp_profile: SpecSecurityContextSeccompProfile,
3905 pub supplemental_groups: Vec<i64>,
3906 pub sysctls: Vec<SysctlsItem>,
3907 pub windows_options: SpecSecurityContextWindowsOptions,
3908 }
3909
3910 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3911 #[serde(rename_all = "camelCase")]
3912 pub struct ContainersItemSecurityContext {
3913 pub allow_privilege_escalation: bool,
3914 pub capabilities: ContainersItemSecurityContextCapabilities,
3915 pub privileged: bool,
3916 pub proc_mount: String,
3917 pub read_only_root_filesystem: bool,
3918 pub run_as_group: i64,
3919 pub run_as_non_root: bool,
3920 pub run_as_user: i64,
3921 pub se_linux_options: ContainersItemSecurityContextSeLinuxOptions,
3922 pub seccomp_profile: ContainersItemSecurityContextSeccompProfile,
3923 pub windows_options: ContainersItemSecurityContextWindowsOptions,
3924 }
3925
3926 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3927 #[serde(rename_all = "camelCase")]
3928 pub struct EphemeralContainersItemSecurityContext {
3929 pub allow_privilege_escalation: bool,
3930 pub capabilities: EphemeralContainersItemSecurityContextCapabilities,
3931 pub privileged: bool,
3932 pub proc_mount: String,
3933 pub read_only_root_filesystem: bool,
3934 pub run_as_group: i64,
3935 pub run_as_non_root: bool,
3936 pub run_as_user: i64,
3937 pub se_linux_options: EphemeralContainersItemSecurityContextSeLinuxOptions,
3938 pub seccomp_profile: EphemeralContainersItemSecurityContextSeccompProfile,
3939 pub windows_options: EphemeralContainersItemSecurityContextWindowsOptions,
3940 }
3941
3942 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3943 #[serde(rename_all = "camelCase")]
3944 pub struct InitContainersItemSecurityContext {
3945 pub allow_privilege_escalation: bool,
3946 pub capabilities: InitContainersItemSecurityContextCapabilities,
3947 pub privileged: bool,
3948 pub proc_mount: String,
3949 pub read_only_root_filesystem: bool,
3950 pub run_as_group: i64,
3951 pub run_as_non_root: bool,
3952 pub run_as_user: i64,
3953 pub se_linux_options: InitContainersItemSecurityContextSeLinuxOptions,
3954 pub seccomp_profile: InitContainersItemSecurityContextSeccompProfile,
3955 pub windows_options: InitContainersItemSecurityContextWindowsOptions,
3956 }
3957
3958 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3959 #[serde(rename_all = "camelCase")]
3960 pub struct Selector {
3961 pub match_expressions: Vec<SelectorMatchExpressionsItem>,
3962 pub match_labels: SelectorMatchLabels,
3963 }
3964
3965 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3966 #[serde(rename_all = "camelCase")]
3967 pub struct Spec {
3968 pub args: Vec<ArgsItem>,
3969 pub dry_run: Vec<DryRunItem>,
3970 pub measurement_retention: Vec<MeasurementRetentionItem>,
3971 pub metrics: Vec<MetricsItem>,
3972 }
3973
3974 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3975 #[serde(rename_all = "camelCase")]
3976 pub struct JobSpec {
3977 pub active_deadline_seconds: i64,
3978 pub backoff_limit: i32,
3979 pub completion_mode: String,
3980 pub completions: i32,
3981 pub manual_selector: bool,
3982 pub parallelism: i32,
3983 pub selector: Selector,
3984 pub suspend: bool,
3985 pub template: Template,
3986 pub ttl_seconds_after_finished: i32,
3987 }
3988
3989 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
3990 #[serde(rename_all = "camelCase")]
3991 pub struct TemplateSpec {
3992 pub active_deadline_seconds: i64,
3993 pub affinity: Affinity,
3994 pub automount_service_account_token: bool,
3995 pub containers: Vec<ContainersItem>,
3996 pub dns_config: DnsConfig,
3997 pub dns_policy: String,
3998 pub enable_service_links: bool,
3999 pub ephemeral_containers: Vec<EphemeralContainersItem>,
4000 pub host_aliases: Vec<HostAliasesItem>,
4001 pub host_i_p_c: bool,
4002 pub host_network: bool,
4003 pub host_p_i_d: bool,
4004 pub hostname: String,
4005 pub image_pull_secrets: Vec<ImagePullSecretsItem>,
4006 pub init_containers: Vec<InitContainersItem>,
4007 pub node_name: String,
4008 pub node_selector: NodeSelector,
4009 pub os: Os,
4010 pub overhead: Overhead,
4011 pub preemption_policy: String,
4012 pub priority: i32,
4013 pub priority_class_name: String,
4014 pub readiness_gates: Vec<ReadinessGatesItem>,
4015 pub restart_policy: String,
4016 pub runtime_class_name: String,
4017 pub scheduler_name: String,
4018 pub security_context: SpecSecurityContext,
4019 pub service_account: String,
4020 pub service_account_name: String,
4021 pub set_hostname_as_f_q_d_n: bool,
4022 pub share_process_namespace: bool,
4023 pub subdomain: String,
4024 pub termination_grace_period_seconds: i64,
4025 pub tolerations: Vec<TolerationsItem>,
4026 pub topology_spread_constraints: Vec<TopologySpreadConstraintsItem>,
4027 pub volumes: serde_json::Map<String, serde_json::Value>,
4028 }
4029
4030 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4031 #[serde(rename_all = "camelCase")]
4032 pub struct ContainersItemStartupProbe {
4033 pub exec: ContainersItemStartupProbeExec,
4034 pub failure_threshold: i32,
4035 pub grpc: ContainersItemStartupProbeGrpc,
4036 pub http_get: ContainersItemStartupProbeHttpGet,
4037 pub initial_delay_seconds: i32,
4038 pub period_seconds: i32,
4039 pub success_threshold: i32,
4040 pub tcp_socket: ContainersItemStartupProbeTcpSocket,
4041 pub termination_grace_period_seconds: i64,
4042 pub timeout_seconds: i32,
4043 }
4044
4045 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4046 #[serde(rename_all = "camelCase")]
4047 pub struct EphemeralContainersItemStartupProbe {
4048 pub exec: EphemeralContainersItemStartupProbeExec,
4049 pub failure_threshold: i32,
4050 pub grpc: EphemeralContainersItemStartupProbeGrpc,
4051 pub http_get: EphemeralContainersItemStartupProbeHttpGet,
4052 pub initial_delay_seconds: i32,
4053 pub period_seconds: i32,
4054 pub success_threshold: i32,
4055 pub tcp_socket: EphemeralContainersItemStartupProbeTcpSocket,
4056 pub termination_grace_period_seconds: i64,
4057 pub timeout_seconds: i32,
4058 }
4059
4060 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4061 #[serde(rename_all = "camelCase")]
4062 pub struct InitContainersItemStartupProbe {
4063 pub exec: InitContainersItemStartupProbeExec,
4064 pub failure_threshold: i32,
4065 pub grpc: InitContainersItemStartupProbeGrpc,
4066 pub http_get: InitContainersItemStartupProbeHttpGet,
4067 pub initial_delay_seconds: i32,
4068 pub period_seconds: i32,
4069 pub success_threshold: i32,
4070 pub tcp_socket: InitContainersItemStartupProbeTcpSocket,
4071 pub termination_grace_period_seconds: i64,
4072 pub timeout_seconds: i32,
4073 }
4074
4075 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4076 #[serde(rename_all = "camelCase")]
4077 pub struct SysctlsItem {
4078 pub name: String,
4079 pub value: String,
4080 }
4081
4082 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4083 #[serde(rename_all = "camelCase")]
4084 pub struct ContainersItemLifecyclePostStartTcpSocket {
4085 pub host: String,
4086 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4087 }
4088
4089 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4090 #[serde(rename_all = "camelCase")]
4091 pub struct ContainersItemLifecyclePreStopTcpSocket {
4092 pub host: String,
4093 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4094 }
4095
4096 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4097 #[serde(rename_all = "camelCase")]
4098 pub struct ContainersItemLivenessProbeTcpSocket {
4099 pub host: String,
4100 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4101 }
4102
4103 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4104 #[serde(rename_all = "camelCase")]
4105 pub struct ContainersItemReadinessProbeTcpSocket {
4106 pub host: String,
4107 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4108 }
4109
4110 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4111 #[serde(rename_all = "camelCase")]
4112 pub struct ContainersItemStartupProbeTcpSocket {
4113 pub host: String,
4114 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4115 }
4116
4117 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4118 #[serde(rename_all = "camelCase")]
4119 pub struct EphemeralContainersItemLifecyclePostStartTcpSocket {
4120 pub host: String,
4121 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4122 }
4123
4124 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4125 #[serde(rename_all = "camelCase")]
4126 pub struct EphemeralContainersItemLifecyclePreStopTcpSocket {
4127 pub host: String,
4128 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4129 }
4130
4131 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4132 #[serde(rename_all = "camelCase")]
4133 pub struct EphemeralContainersItemLivenessProbeTcpSocket {
4134 pub host: String,
4135 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4136 }
4137
4138 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4139 #[serde(rename_all = "camelCase")]
4140 pub struct EphemeralContainersItemReadinessProbeTcpSocket {
4141 pub host: String,
4142 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4143 }
4144
4145 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4146 #[serde(rename_all = "camelCase")]
4147 pub struct EphemeralContainersItemStartupProbeTcpSocket {
4148 pub host: String,
4149 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4150 }
4151
4152 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4153 #[serde(rename_all = "camelCase")]
4154 pub struct InitContainersItemLifecyclePostStartTcpSocket {
4155 pub host: String,
4156 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4157 }
4158
4159 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4160 #[serde(rename_all = "camelCase")]
4161 pub struct InitContainersItemLifecyclePreStopTcpSocket {
4162 pub host: String,
4163 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4164 }
4165
4166 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4167 #[serde(rename_all = "camelCase")]
4168 pub struct InitContainersItemLivenessProbeTcpSocket {
4169 pub host: String,
4170 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4171 }
4172
4173 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4174 #[serde(rename_all = "camelCase")]
4175 pub struct InitContainersItemReadinessProbeTcpSocket {
4176 pub host: String,
4177 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4178 }
4179
4180 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4181 #[serde(rename_all = "camelCase")]
4182 pub struct InitContainersItemStartupProbeTcpSocket {
4183 pub host: String,
4184 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4185 }
4186
4187 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4188 #[serde(rename_all = "camelCase")]
4189 pub struct Template {
4190 pub metadata: TemplateMetadata,
4191 pub spec: TemplateSpec,
4192 }
4193
4194 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4195 #[serde(rename_all = "camelCase")]
4196 pub struct Threshold {
4197 pub marginal: i64,
4198 pub pass: i64,
4199 }
4200
4201 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4202 #[serde(rename_all = "camelCase")]
4203 pub struct TolerationsItem {
4204 pub effect: String,
4205 pub key: String,
4206 pub operator: String,
4207 pub toleration_seconds: i64,
4208 pub value: String,
4209 }
4210
4211 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4212 #[serde(rename_all = "camelCase")]
4213 pub struct TopologySpreadConstraintsItem {
4214 pub label_selector: TopologySpreadConstraintsItemLabelSelector,
4215 pub max_skew: i32,
4216 pub topology_key: String,
4217 pub when_unsatisfiable: String,
4218 }
4219
4220 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4221 #[serde(rename_all = "camelCase")]
4222 pub struct ArgsItemValueFrom {
4223 pub field_ref: ArgsItemValueFromFieldRef,
4224 pub secret_key_ref: ArgsItemValueFromSecretKeyRef,
4225 }
4226
4227 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4228 #[serde(rename_all = "camelCase")]
4229 pub struct ContainersItemEnvItemValueFrom {
4230 pub config_map_key_ref: ContainersItemEnvItemValueFromConfigMapKeyRef,
4231 pub field_ref: ContainersItemEnvItemValueFromFieldRef,
4232 pub resource_field_ref: ContainersItemEnvItemValueFromResourceFieldRef,
4233 pub secret_key_ref: ContainersItemEnvItemValueFromSecretKeyRef,
4234 }
4235
4236 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4237 #[serde(rename_all = "camelCase")]
4238 pub struct EphemeralContainersItemEnvItemValueFrom {
4239 pub config_map_key_ref: EphemeralContainersItemEnvItemValueFromConfigMapKeyRef,
4240 pub field_ref: EphemeralContainersItemEnvItemValueFromFieldRef,
4241 pub resource_field_ref: EphemeralContainersItemEnvItemValueFromResourceFieldRef,
4242 pub secret_key_ref: EphemeralContainersItemEnvItemValueFromSecretKeyRef,
4243 }
4244
4245 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4246 #[serde(rename_all = "camelCase")]
4247 pub struct InitContainersItemEnvItemValueFrom {
4248 pub config_map_key_ref: InitContainersItemEnvItemValueFromConfigMapKeyRef,
4249 pub field_ref: InitContainersItemEnvItemValueFromFieldRef,
4250 pub resource_field_ref: InitContainersItemEnvItemValueFromResourceFieldRef,
4251 pub secret_key_ref: InitContainersItemEnvItemValueFromSecretKeyRef,
4252 }
4253
4254 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4255 #[serde(rename_all = "camelCase")]
4256 pub struct ContainersItemVolumeDevicesItem {
4257 pub device_path: String,
4258 pub name: String,
4259 }
4260
4261 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4262 #[serde(rename_all = "camelCase")]
4263 pub struct EphemeralContainersItemVolumeDevicesItem {
4264 pub device_path: String,
4265 pub name: String,
4266 }
4267
4268 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4269 #[serde(rename_all = "camelCase")]
4270 pub struct InitContainersItemVolumeDevicesItem {
4271 pub device_path: String,
4272 pub name: String,
4273 }
4274
4275 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4276 #[serde(rename_all = "camelCase")]
4277 pub struct ContainersItemVolumeMountsItem {
4278 pub mount_path: String,
4279 pub mount_propagation: String,
4280 pub name: String,
4281 pub read_only: bool,
4282 pub sub_path: String,
4283 pub sub_path_expr: String,
4284 }
4285
4286 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4287 #[serde(rename_all = "camelCase")]
4288 pub struct EphemeralContainersItemVolumeMountsItem {
4289 pub mount_path: String,
4290 pub mount_propagation: String,
4291 pub name: String,
4292 pub read_only: bool,
4293 pub sub_path: String,
4294 pub sub_path_expr: String,
4295 }
4296
4297 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4298 #[serde(rename_all = "camelCase")]
4299 pub struct InitContainersItemVolumeMountsItem {
4300 pub mount_path: String,
4301 pub mount_propagation: String,
4302 pub name: String,
4303 pub read_only: bool,
4304 pub sub_path: String,
4305 pub sub_path_expr: String,
4306 }
4307
4308 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4309 #[serde(rename_all = "camelCase")]
4310 pub struct Wavefront {
4311 pub address: String,
4312 pub query: String,
4313 }
4314
4315 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4316 #[serde(rename_all = "camelCase")]
4317 pub struct Web {
4318 pub body: String,
4319 pub headers: Vec<HeadersItem>,
4320 pub insecure: bool,
4321 pub json_path: String,
4322 pub method: String,
4323 pub timeout_seconds: i64,
4324 pub url: String,
4325 }
4326
4327 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4328 #[serde(rename_all = "camelCase")]
4329 pub struct ContainersItemSecurityContextWindowsOptions {
4330 pub gmsa_credential_spec: String,
4331 pub gmsa_credential_spec_name: String,
4332 pub host_process: bool,
4333 pub run_as_user_name: String,
4334 }
4335
4336 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4337 #[serde(rename_all = "camelCase")]
4338 pub struct EphemeralContainersItemSecurityContextWindowsOptions {
4339 pub gmsa_credential_spec: String,
4340 pub gmsa_credential_spec_name: String,
4341 pub host_process: bool,
4342 pub run_as_user_name: String,
4343 }
4344
4345 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4346 #[serde(rename_all = "camelCase")]
4347 pub struct InitContainersItemSecurityContextWindowsOptions {
4348 pub gmsa_credential_spec: String,
4349 pub gmsa_credential_spec_name: String,
4350 pub host_process: bool,
4351 pub run_as_user_name: String,
4352 }
4353
4354 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4355 #[serde(rename_all = "camelCase")]
4356 pub struct SpecSecurityContextWindowsOptions {
4357 pub gmsa_credential_spec: String,
4358 pub gmsa_credential_spec_name: String,
4359 pub host_process: bool,
4360 pub run_as_user_name: String,
4361 }
4362 }
4363 pub mod cluster_analysis_template {
4364 #[derive(serde::Deserialize, Debug, PartialEq)]
4365 pub struct ClusterAnalysisTemplate {
4366 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
4367 pub spec: Spec,
4368 }
4369
4370 impl k8s_openapi::Resource for ClusterAnalysisTemplate {
4371 type Scope = k8s_openapi::ClusterResourceScope;
4372
4373 const API_VERSION: &'static str = "argoproj.io/v1alpha1";
4374 const GROUP: &'static str = "argoproj.io";
4375 const KIND: &'static str = "ClusterAnalysisTemplate";
4376 const VERSION: &'static str = "v1alpha1";
4377 const URL_PATH_SEGMENT: &'static str = "TODO";
4378 }
4379
4380 impl k8s_openapi::Metadata for ClusterAnalysisTemplate {
4381 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
4382
4383 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
4384 &self.metadata
4385 }
4386
4387 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
4388 &mut self.metadata
4389 }
4390 }
4391
4392 impl serde::Serialize for ClusterAnalysisTemplate {
4393 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
4394 where
4395 S: serde::Serializer,
4396 {
4397 use serde::ser::SerializeStruct;
4398 let mut state = serializer.serialize_struct("ClusterAnalysisTemplate", 4)?;
4399 state.serialize_field(
4400 "apiVersion",
4401 <Self as k8s_openapi::Resource>::API_VERSION,
4402 )?;
4403 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
4404 state.serialize_field("metadata", &self.metadata)?;
4405 state.serialize_field("spec", &self.spec)?;
4406 state.end()
4407 }
4408 }
4409
4410 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4411 #[serde(rename_all = "camelCase")]
4412 pub struct Affinity {
4413 pub node_affinity: NodeAffinity,
4414 pub pod_affinity: PodAffinity,
4415 pub pod_anti_affinity: PodAntiAffinity,
4416 }
4417
4418 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4419 #[serde(rename_all = "camelCase")]
4420 pub struct JobMetadataAnnotations {
4421 pub properties: std::collections::HashMap<String, String>,
4422 }
4423
4424 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4425 #[serde(rename_all = "camelCase")]
4426 pub struct TemplateMetadataAnnotations {
4427 pub properties: std::collections::HashMap<String, String>,
4428 }
4429
4430 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4431 #[serde(rename_all = "camelCase")]
4432 pub struct ArgsItem {
4433 pub name: String,
4434 pub value: String,
4435 pub value_from: ArgsItemValueFrom,
4436 }
4437
4438 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4439 #[serde(rename_all = "camelCase")]
4440 pub struct ContainersItemSecurityContextCapabilities {
4441 pub add: Vec<String>,
4442 pub drop: Vec<String>,
4443 }
4444
4445 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4446 #[serde(rename_all = "camelCase")]
4447 pub struct EphemeralContainersItemSecurityContextCapabilities {
4448 pub add: Vec<String>,
4449 pub drop: Vec<String>,
4450 }
4451
4452 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4453 #[serde(rename_all = "camelCase")]
4454 pub struct InitContainersItemSecurityContextCapabilities {
4455 pub add: Vec<String>,
4456 pub drop: Vec<String>,
4457 }
4458
4459 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4460 #[serde(rename_all = "camelCase")]
4461 pub struct CloudWatch {
4462 pub interval: String,
4463 pub metric_data_queries: Vec<MetricDataQueriesItem>,
4464 }
4465
4466 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4467 #[serde(rename_all = "camelCase")]
4468 pub struct ContainersItemEnvItemValueFromConfigMapKeyRef {
4469 pub key: String,
4470 pub name: String,
4471 pub optional: bool,
4472 }
4473
4474 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4475 #[serde(rename_all = "camelCase")]
4476 pub struct EphemeralContainersItemEnvItemValueFromConfigMapKeyRef {
4477 pub key: String,
4478 pub name: String,
4479 pub optional: bool,
4480 }
4481
4482 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4483 #[serde(rename_all = "camelCase")]
4484 pub struct InitContainersItemEnvItemValueFromConfigMapKeyRef {
4485 pub key: String,
4486 pub name: String,
4487 pub optional: bool,
4488 }
4489
4490 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4491 #[serde(rename_all = "camelCase")]
4492 pub struct ContainersItemEnvFromItemConfigMapRef {
4493 pub name: String,
4494 pub optional: bool,
4495 }
4496
4497 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4498 #[serde(rename_all = "camelCase")]
4499 pub struct EphemeralContainersItemEnvFromItemConfigMapRef {
4500 pub name: String,
4501 pub optional: bool,
4502 }
4503
4504 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4505 #[serde(rename_all = "camelCase")]
4506 pub struct InitContainersItemEnvFromItemConfigMapRef {
4507 pub name: String,
4508 pub optional: bool,
4509 }
4510
4511 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4512 #[serde(rename_all = "camelCase")]
4513 pub struct ContainersItem {
4514 pub args: Vec<String>,
4515 pub command: Vec<String>,
4516 pub env: Vec<ContainersItemEnvItem>,
4517 pub env_from: Vec<ContainersItemEnvFromItem>,
4518 pub image: String,
4519 pub image_pull_policy: String,
4520 pub lifecycle: ContainersItemLifecycle,
4521 pub liveness_probe: ContainersItemLivenessProbe,
4522 pub name: String,
4523 pub ports: Vec<ContainersItemPortsItem>,
4524 pub readiness_probe: ContainersItemReadinessProbe,
4525 pub resources: ContainersItemResources,
4526 pub security_context: ContainersItemSecurityContext,
4527 pub startup_probe: ContainersItemStartupProbe,
4528 pub stdin: bool,
4529 pub stdin_once: bool,
4530 pub termination_message_path: String,
4531 pub termination_message_policy: String,
4532 pub tty: bool,
4533 pub volume_devices: Vec<ContainersItemVolumeDevicesItem>,
4534 pub volume_mounts: Vec<ContainersItemVolumeMountsItem>,
4535 pub working_dir: String,
4536 }
4537
4538 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4539 #[serde(rename_all = "camelCase")]
4540 pub struct ControlScope {
4541 pub end: String,
4542 pub region: String,
4543 pub scope: String,
4544 pub start: String,
4545 pub step: i64,
4546 }
4547
4548 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4549 #[serde(rename_all = "camelCase")]
4550 pub struct Datadog {
4551 pub interval: String,
4552 pub query: String,
4553 }
4554
4555 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4556 #[serde(rename_all = "camelCase")]
4557 pub struct DimensionsItem {
4558 pub name: String,
4559 pub value: String,
4560 }
4561
4562 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4563 #[serde(rename_all = "camelCase")]
4564 pub struct DnsConfig {
4565 pub nameservers: Vec<String>,
4566 pub options: Vec<OptionsItem>,
4567 pub searches: Vec<String>,
4568 }
4569
4570 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4571 #[serde(rename_all = "camelCase")]
4572 pub struct DryRunItem {
4573 pub metric_name: String,
4574 }
4575
4576 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4577 #[serde(rename_all = "camelCase")]
4578 pub struct ContainersItemEnvFromItem {
4579 pub config_map_ref: ContainersItemEnvFromItemConfigMapRef,
4580 pub prefix: String,
4581 pub secret_ref: ContainersItemEnvFromItemSecretRef,
4582 }
4583
4584 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4585 #[serde(rename_all = "camelCase")]
4586 pub struct EphemeralContainersItemEnvFromItem {
4587 pub config_map_ref: EphemeralContainersItemEnvFromItemConfigMapRef,
4588 pub prefix: String,
4589 pub secret_ref: EphemeralContainersItemEnvFromItemSecretRef,
4590 }
4591
4592 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4593 #[serde(rename_all = "camelCase")]
4594 pub struct InitContainersItemEnvFromItem {
4595 pub config_map_ref: InitContainersItemEnvFromItemConfigMapRef,
4596 pub prefix: String,
4597 pub secret_ref: InitContainersItemEnvFromItemSecretRef,
4598 }
4599
4600 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4601 #[serde(rename_all = "camelCase")]
4602 pub struct ContainersItemEnvItem {
4603 pub name: String,
4604 pub value: String,
4605 pub value_from: ContainersItemEnvItemValueFrom,
4606 }
4607
4608 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4609 #[serde(rename_all = "camelCase")]
4610 pub struct EphemeralContainersItemEnvItem {
4611 pub name: String,
4612 pub value: String,
4613 pub value_from: EphemeralContainersItemEnvItemValueFrom,
4614 }
4615
4616 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4617 #[serde(rename_all = "camelCase")]
4618 pub struct InitContainersItemEnvItem {
4619 pub name: String,
4620 pub value: String,
4621 pub value_from: InitContainersItemEnvItemValueFrom,
4622 }
4623
4624 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4625 #[serde(rename_all = "camelCase")]
4626 pub struct EphemeralContainersItem {
4627 pub args: Vec<String>,
4628 pub command: Vec<String>,
4629 pub env: Vec<EphemeralContainersItemEnvItem>,
4630 pub env_from: Vec<EphemeralContainersItemEnvFromItem>,
4631 pub image: String,
4632 pub image_pull_policy: String,
4633 pub lifecycle: EphemeralContainersItemLifecycle,
4634 pub liveness_probe: EphemeralContainersItemLivenessProbe,
4635 pub name: String,
4636 pub ports: Vec<EphemeralContainersItemPortsItem>,
4637 pub readiness_probe: EphemeralContainersItemReadinessProbe,
4638 pub resources: EphemeralContainersItemResources,
4639 pub security_context: EphemeralContainersItemSecurityContext,
4640 pub startup_probe: EphemeralContainersItemStartupProbe,
4641 pub stdin: bool,
4642 pub stdin_once: bool,
4643 pub target_container_name: String,
4644 pub termination_message_path: String,
4645 pub termination_message_policy: String,
4646 pub tty: bool,
4647 pub volume_devices: Vec<EphemeralContainersItemVolumeDevicesItem>,
4648 pub volume_mounts: Vec<EphemeralContainersItemVolumeMountsItem>,
4649 pub working_dir: String,
4650 }
4651
4652 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4653 #[serde(rename_all = "camelCase")]
4654 pub struct ContainersItemLifecyclePostStartExec {
4655 pub command: Vec<String>,
4656 }
4657
4658 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4659 #[serde(rename_all = "camelCase")]
4660 pub struct ContainersItemLifecyclePreStopExec {
4661 pub command: Vec<String>,
4662 }
4663
4664 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4665 #[serde(rename_all = "camelCase")]
4666 pub struct ContainersItemLivenessProbeExec {
4667 pub command: Vec<String>,
4668 }
4669
4670 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4671 #[serde(rename_all = "camelCase")]
4672 pub struct ContainersItemReadinessProbeExec {
4673 pub command: Vec<String>,
4674 }
4675
4676 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4677 #[serde(rename_all = "camelCase")]
4678 pub struct ContainersItemStartupProbeExec {
4679 pub command: Vec<String>,
4680 }
4681
4682 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4683 #[serde(rename_all = "camelCase")]
4684 pub struct EphemeralContainersItemLifecyclePostStartExec {
4685 pub command: Vec<String>,
4686 }
4687
4688 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4689 #[serde(rename_all = "camelCase")]
4690 pub struct EphemeralContainersItemLifecyclePreStopExec {
4691 pub command: Vec<String>,
4692 }
4693
4694 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4695 #[serde(rename_all = "camelCase")]
4696 pub struct EphemeralContainersItemLivenessProbeExec {
4697 pub command: Vec<String>,
4698 }
4699
4700 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4701 #[serde(rename_all = "camelCase")]
4702 pub struct EphemeralContainersItemReadinessProbeExec {
4703 pub command: Vec<String>,
4704 }
4705
4706 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4707 #[serde(rename_all = "camelCase")]
4708 pub struct EphemeralContainersItemStartupProbeExec {
4709 pub command: Vec<String>,
4710 }
4711
4712 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4713 #[serde(rename_all = "camelCase")]
4714 pub struct InitContainersItemLifecyclePostStartExec {
4715 pub command: Vec<String>,
4716 }
4717
4718 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4719 #[serde(rename_all = "camelCase")]
4720 pub struct InitContainersItemLifecyclePreStopExec {
4721 pub command: Vec<String>,
4722 }
4723
4724 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4725 #[serde(rename_all = "camelCase")]
4726 pub struct InitContainersItemLivenessProbeExec {
4727 pub command: Vec<String>,
4728 }
4729
4730 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4731 #[serde(rename_all = "camelCase")]
4732 pub struct InitContainersItemReadinessProbeExec {
4733 pub command: Vec<String>,
4734 }
4735
4736 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4737 #[serde(rename_all = "camelCase")]
4738 pub struct InitContainersItemStartupProbeExec {
4739 pub command: Vec<String>,
4740 }
4741
4742 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4743 #[serde(rename_all = "camelCase")]
4744 pub struct ExperimentScope {
4745 pub end: String,
4746 pub region: String,
4747 pub scope: String,
4748 pub start: String,
4749 pub step: i64,
4750 }
4751
4752 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4753 #[serde(rename_all = "camelCase")]
4754 pub struct ArgsItemValueFromFieldRef {
4755 pub field_path: String,
4756 }
4757
4758 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4759 #[serde(rename_all = "camelCase")]
4760 pub struct ContainersItemEnvItemValueFromFieldRef {
4761 pub api_version: String,
4762 pub field_path: String,
4763 }
4764
4765 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4766 #[serde(rename_all = "camelCase")]
4767 pub struct EphemeralContainersItemEnvItemValueFromFieldRef {
4768 pub api_version: String,
4769 pub field_path: String,
4770 }
4771
4772 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4773 #[serde(rename_all = "camelCase")]
4774 pub struct InitContainersItemEnvItemValueFromFieldRef {
4775 pub api_version: String,
4776 pub field_path: String,
4777 }
4778
4779 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4780 #[serde(rename_all = "camelCase")]
4781 pub struct Graphite {
4782 pub address: String,
4783 pub query: String,
4784 }
4785
4786 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4787 #[serde(rename_all = "camelCase")]
4788 pub struct ContainersItemLivenessProbeGrpc {
4789 pub port: i32,
4790 pub service: String,
4791 }
4792
4793 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4794 #[serde(rename_all = "camelCase")]
4795 pub struct ContainersItemReadinessProbeGrpc {
4796 pub port: i32,
4797 pub service: String,
4798 }
4799
4800 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4801 #[serde(rename_all = "camelCase")]
4802 pub struct ContainersItemStartupProbeGrpc {
4803 pub port: i32,
4804 pub service: String,
4805 }
4806
4807 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4808 #[serde(rename_all = "camelCase")]
4809 pub struct EphemeralContainersItemLivenessProbeGrpc {
4810 pub port: i32,
4811 pub service: String,
4812 }
4813
4814 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4815 #[serde(rename_all = "camelCase")]
4816 pub struct EphemeralContainersItemReadinessProbeGrpc {
4817 pub port: i32,
4818 pub service: String,
4819 }
4820
4821 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4822 #[serde(rename_all = "camelCase")]
4823 pub struct EphemeralContainersItemStartupProbeGrpc {
4824 pub port: i32,
4825 pub service: String,
4826 }
4827
4828 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4829 #[serde(rename_all = "camelCase")]
4830 pub struct InitContainersItemLivenessProbeGrpc {
4831 pub port: i32,
4832 pub service: String,
4833 }
4834
4835 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4836 #[serde(rename_all = "camelCase")]
4837 pub struct InitContainersItemReadinessProbeGrpc {
4838 pub port: i32,
4839 pub service: String,
4840 }
4841
4842 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4843 #[serde(rename_all = "camelCase")]
4844 pub struct InitContainersItemStartupProbeGrpc {
4845 pub port: i32,
4846 pub service: String,
4847 }
4848
4849 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4850 #[serde(rename_all = "camelCase")]
4851 pub struct HeadersItem {
4852 pub key: String,
4853 pub value: String,
4854 }
4855
4856 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4857 #[serde(rename_all = "camelCase")]
4858 pub struct HostAliasesItem {
4859 pub hostnames: Vec<String>,
4860 pub ip: String,
4861 }
4862
4863 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4864 #[serde(rename_all = "camelCase")]
4865 pub struct ContainersItemLifecyclePostStartHttpGet {
4866 pub host: String,
4867 pub http_headers: Vec<ContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
4868 pub path: String,
4869 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4870 pub scheme: String,
4871 }
4872
4873 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4874 #[serde(rename_all = "camelCase")]
4875 pub struct ContainersItemLifecyclePreStopHttpGet {
4876 pub host: String,
4877 pub http_headers: Vec<ContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
4878 pub path: String,
4879 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4880 pub scheme: String,
4881 }
4882
4883 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4884 #[serde(rename_all = "camelCase")]
4885 pub struct ContainersItemLivenessProbeHttpGet {
4886 pub host: String,
4887 pub http_headers: Vec<ContainersItemLivenessProbeHttpGetHttpHeadersItem>,
4888 pub path: String,
4889 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4890 pub scheme: String,
4891 }
4892
4893 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4894 #[serde(rename_all = "camelCase")]
4895 pub struct ContainersItemReadinessProbeHttpGet {
4896 pub host: String,
4897 pub http_headers: Vec<ContainersItemReadinessProbeHttpGetHttpHeadersItem>,
4898 pub path: String,
4899 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4900 pub scheme: String,
4901 }
4902
4903 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4904 #[serde(rename_all = "camelCase")]
4905 pub struct ContainersItemStartupProbeHttpGet {
4906 pub host: String,
4907 pub http_headers: Vec<ContainersItemStartupProbeHttpGetHttpHeadersItem>,
4908 pub path: String,
4909 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4910 pub scheme: String,
4911 }
4912
4913 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4914 #[serde(rename_all = "camelCase")]
4915 pub struct EphemeralContainersItemLifecyclePostStartHttpGet {
4916 pub host: String,
4917 pub http_headers:
4918 Vec<EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
4919 pub path: String,
4920 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4921 pub scheme: String,
4922 }
4923
4924 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4925 #[serde(rename_all = "camelCase")]
4926 pub struct EphemeralContainersItemLifecyclePreStopHttpGet {
4927 pub host: String,
4928 pub http_headers:
4929 Vec<EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
4930 pub path: String,
4931 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4932 pub scheme: String,
4933 }
4934
4935 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4936 #[serde(rename_all = "camelCase")]
4937 pub struct EphemeralContainersItemLivenessProbeHttpGet {
4938 pub host: String,
4939 pub http_headers: Vec<EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem>,
4940 pub path: String,
4941 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4942 pub scheme: String,
4943 }
4944
4945 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4946 #[serde(rename_all = "camelCase")]
4947 pub struct EphemeralContainersItemReadinessProbeHttpGet {
4948 pub host: String,
4949 pub http_headers: Vec<EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem>,
4950 pub path: String,
4951 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4952 pub scheme: String,
4953 }
4954
4955 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4956 #[serde(rename_all = "camelCase")]
4957 pub struct EphemeralContainersItemStartupProbeHttpGet {
4958 pub host: String,
4959 pub http_headers: Vec<EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem>,
4960 pub path: String,
4961 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4962 pub scheme: String,
4963 }
4964
4965 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4966 #[serde(rename_all = "camelCase")]
4967 pub struct InitContainersItemLifecyclePostStartHttpGet {
4968 pub host: String,
4969 pub http_headers: Vec<InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
4970 pub path: String,
4971 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4972 pub scheme: String,
4973 }
4974
4975 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4976 #[serde(rename_all = "camelCase")]
4977 pub struct InitContainersItemLifecyclePreStopHttpGet {
4978 pub host: String,
4979 pub http_headers: Vec<InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
4980 pub path: String,
4981 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4982 pub scheme: String,
4983 }
4984
4985 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4986 #[serde(rename_all = "camelCase")]
4987 pub struct InitContainersItemLivenessProbeHttpGet {
4988 pub host: String,
4989 pub http_headers: Vec<InitContainersItemLivenessProbeHttpGetHttpHeadersItem>,
4990 pub path: String,
4991 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
4992 pub scheme: String,
4993 }
4994
4995 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
4996 #[serde(rename_all = "camelCase")]
4997 pub struct InitContainersItemReadinessProbeHttpGet {
4998 pub host: String,
4999 pub http_headers: Vec<InitContainersItemReadinessProbeHttpGetHttpHeadersItem>,
5000 pub path: String,
5001 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5002 pub scheme: String,
5003 }
5004
5005 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5006 #[serde(rename_all = "camelCase")]
5007 pub struct InitContainersItemStartupProbeHttpGet {
5008 pub host: String,
5009 pub http_headers: Vec<InitContainersItemStartupProbeHttpGetHttpHeadersItem>,
5010 pub path: String,
5011 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5012 pub scheme: String,
5013 }
5014
5015 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5016 #[serde(rename_all = "camelCase")]
5017 pub struct ContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
5018 pub name: String,
5019 pub value: String,
5020 }
5021
5022 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5023 #[serde(rename_all = "camelCase")]
5024 pub struct ContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
5025 pub name: String,
5026 pub value: String,
5027 }
5028
5029 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5030 #[serde(rename_all = "camelCase")]
5031 pub struct ContainersItemLivenessProbeHttpGetHttpHeadersItem {
5032 pub name: String,
5033 pub value: String,
5034 }
5035
5036 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5037 #[serde(rename_all = "camelCase")]
5038 pub struct ContainersItemReadinessProbeHttpGetHttpHeadersItem {
5039 pub name: String,
5040 pub value: String,
5041 }
5042
5043 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5044 #[serde(rename_all = "camelCase")]
5045 pub struct ContainersItemStartupProbeHttpGetHttpHeadersItem {
5046 pub name: String,
5047 pub value: String,
5048 }
5049
5050 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5051 #[serde(rename_all = "camelCase")]
5052 pub struct EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
5053 pub name: String,
5054 pub value: String,
5055 }
5056
5057 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5058 #[serde(rename_all = "camelCase")]
5059 pub struct EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
5060 pub name: String,
5061 pub value: String,
5062 }
5063
5064 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5065 #[serde(rename_all = "camelCase")]
5066 pub struct EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem {
5067 pub name: String,
5068 pub value: String,
5069 }
5070
5071 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5072 #[serde(rename_all = "camelCase")]
5073 pub struct EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem {
5074 pub name: String,
5075 pub value: String,
5076 }
5077
5078 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5079 #[serde(rename_all = "camelCase")]
5080 pub struct EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem {
5081 pub name: String,
5082 pub value: String,
5083 }
5084
5085 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5086 #[serde(rename_all = "camelCase")]
5087 pub struct InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
5088 pub name: String,
5089 pub value: String,
5090 }
5091
5092 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5093 #[serde(rename_all = "camelCase")]
5094 pub struct InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
5095 pub name: String,
5096 pub value: String,
5097 }
5098
5099 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5100 #[serde(rename_all = "camelCase")]
5101 pub struct InitContainersItemLivenessProbeHttpGetHttpHeadersItem {
5102 pub name: String,
5103 pub value: String,
5104 }
5105
5106 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5107 #[serde(rename_all = "camelCase")]
5108 pub struct InitContainersItemReadinessProbeHttpGetHttpHeadersItem {
5109 pub name: String,
5110 pub value: String,
5111 }
5112
5113 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5114 #[serde(rename_all = "camelCase")]
5115 pub struct InitContainersItemStartupProbeHttpGetHttpHeadersItem {
5116 pub name: String,
5117 pub value: String,
5118 }
5119
5120 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5121 #[serde(rename_all = "camelCase")]
5122 pub struct ImagePullSecretsItem {
5123 pub name: String,
5124 }
5125
5126 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5127 #[serde(rename_all = "camelCase")]
5128 pub struct Influxdb {
5129 pub profile: String,
5130 pub query: String,
5131 }
5132
5133 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5134 #[serde(rename_all = "camelCase")]
5135 pub struct InitContainersItem {
5136 pub args: Vec<String>,
5137 pub command: Vec<String>,
5138 pub env: Vec<InitContainersItemEnvItem>,
5139 pub env_from: Vec<InitContainersItemEnvFromItem>,
5140 pub image: String,
5141 pub image_pull_policy: String,
5142 pub lifecycle: InitContainersItemLifecycle,
5143 pub liveness_probe: InitContainersItemLivenessProbe,
5144 pub name: String,
5145 pub ports: Vec<InitContainersItemPortsItem>,
5146 pub readiness_probe: InitContainersItemReadinessProbe,
5147 pub resources: InitContainersItemResources,
5148 pub security_context: InitContainersItemSecurityContext,
5149 pub startup_probe: InitContainersItemStartupProbe,
5150 pub stdin: bool,
5151 pub stdin_once: bool,
5152 pub termination_message_path: String,
5153 pub termination_message_policy: String,
5154 pub tty: bool,
5155 pub volume_devices: Vec<InitContainersItemVolumeDevicesItem>,
5156 pub volume_mounts: Vec<InitContainersItemVolumeMountsItem>,
5157 pub working_dir: String,
5158 }
5159
5160 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5161 #[serde(rename_all = "camelCase")]
5162 pub struct Job {
5163 pub metadata: JobMetadata,
5164 pub spec: JobSpec,
5165 }
5166
5167 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5168 #[serde(rename_all = "camelCase")]
5169 pub struct Kayenta {
5170 pub address: String,
5171 pub application: String,
5172 pub canary_config_name: String,
5173 pub configuration_account_name: String,
5174 pub metrics_account_name: String,
5175 pub scopes: Vec<ScopesItem>,
5176 pub storage_account_name: String,
5177 pub threshold: Threshold,
5178 }
5179
5180 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5181 #[serde(rename_all = "camelCase")]
5182 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
5183 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
5184 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
5185 }
5186
5187 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5188 #[serde(rename_all = "camelCase")]
5189 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
5190 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
5191 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
5192 }
5193
5194 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5195 #[serde(rename_all = "camelCase")]
5196 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
5197 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
5198 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
5199 }
5200
5201 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5202 #[serde(rename_all = "camelCase")]
5203 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
5204 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
5205 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
5206 }
5207
5208 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5209 #[serde(rename_all = "camelCase")]
5210 pub struct TopologySpreadConstraintsItemLabelSelector {
5211 pub match_expressions:
5212 Vec<TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem>,
5213 pub match_labels: TopologySpreadConstraintsItemLabelSelectorMatchLabels,
5214 }
5215
5216 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5217 #[serde(rename_all = "camelCase")]
5218 pub struct JobMetadataLabels {
5219 pub properties: std::collections::HashMap<String, String>,
5220 }
5221
5222 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5223 #[serde(rename_all = "camelCase")]
5224 pub struct TemplateMetadataLabels {
5225 pub properties: std::collections::HashMap<String, String>,
5226 }
5227
5228 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5229 #[serde(rename_all = "camelCase")]
5230 pub struct ContainersItemLifecycle {
5231 pub post_start: ContainersItemLifecyclePostStart,
5232 pub pre_stop: ContainersItemLifecyclePreStop,
5233 }
5234
5235 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5236 #[serde(rename_all = "camelCase")]
5237 pub struct EphemeralContainersItemLifecycle {
5238 pub post_start: EphemeralContainersItemLifecyclePostStart,
5239 pub pre_stop: EphemeralContainersItemLifecyclePreStop,
5240 }
5241
5242 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5243 #[serde(rename_all = "camelCase")]
5244 pub struct InitContainersItemLifecycle {
5245 pub post_start: InitContainersItemLifecyclePostStart,
5246 pub pre_stop: InitContainersItemLifecyclePreStop,
5247 }
5248
5249 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5250 #[serde(rename_all = "camelCase")]
5251 pub struct ContainersItemLivenessProbe {
5252 pub exec: ContainersItemLivenessProbeExec,
5253 pub failure_threshold: i32,
5254 pub grpc: ContainersItemLivenessProbeGrpc,
5255 pub http_get: ContainersItemLivenessProbeHttpGet,
5256 pub initial_delay_seconds: i32,
5257 pub period_seconds: i32,
5258 pub success_threshold: i32,
5259 pub tcp_socket: ContainersItemLivenessProbeTcpSocket,
5260 pub termination_grace_period_seconds: i64,
5261 pub timeout_seconds: i32,
5262 }
5263
5264 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5265 #[serde(rename_all = "camelCase")]
5266 pub struct EphemeralContainersItemLivenessProbe {
5267 pub exec: EphemeralContainersItemLivenessProbeExec,
5268 pub failure_threshold: i32,
5269 pub grpc: EphemeralContainersItemLivenessProbeGrpc,
5270 pub http_get: EphemeralContainersItemLivenessProbeHttpGet,
5271 pub initial_delay_seconds: i32,
5272 pub period_seconds: i32,
5273 pub success_threshold: i32,
5274 pub tcp_socket: EphemeralContainersItemLivenessProbeTcpSocket,
5275 pub termination_grace_period_seconds: i64,
5276 pub timeout_seconds: i32,
5277 }
5278
5279 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5280 #[serde(rename_all = "camelCase")]
5281 pub struct InitContainersItemLivenessProbe {
5282 pub exec: InitContainersItemLivenessProbeExec,
5283 pub failure_threshold: i32,
5284 pub grpc: InitContainersItemLivenessProbeGrpc,
5285 pub http_get: InitContainersItemLivenessProbeHttpGet,
5286 pub initial_delay_seconds: i32,
5287 pub period_seconds: i32,
5288 pub success_threshold: i32,
5289 pub tcp_socket: InitContainersItemLivenessProbeTcpSocket,
5290 pub termination_grace_period_seconds: i64,
5291 pub timeout_seconds: i32,
5292 }
5293
5294 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5295 #[serde(rename_all = "camelCase")]
5296 pub struct SelectorMatchExpressionsItem {
5297 pub key: String,
5298 pub operator: String,
5299 pub values: Vec<String>,
5300 }
5301
5302 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5303 #[serde(rename_all = "camelCase")]
5304 pub struct PreferenceMatchExpressionsItem {
5305 pub key: String,
5306 pub operator: String,
5307 pub values: Vec<String>,
5308 }
5309
5310 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5311 #[serde(rename_all = "camelCase")]
5312 pub struct NodeSelectorTermsItemMatchExpressionsItem {
5313 pub key: String,
5314 pub operator: String,
5315 pub values: Vec<String>,
5316 }
5317
5318 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5319 #[serde(rename_all = "camelCase")]
5320 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
5321 {
5322 pub key: String,
5323 pub operator: String,
5324 pub values: Vec<String>,
5325 }
5326
5327 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5328 #[serde(rename_all = "camelCase")]
5329 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
5330 {
5331 pub key: String,
5332 pub operator: String,
5333 pub values: Vec<String>,
5334 }
5335
5336 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5337 #[serde(rename_all = "camelCase")]
5338 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
5339 {
5340 pub key: String,
5341 pub operator: String,
5342 pub values: Vec<String>,
5343 }
5344
5345 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5346 #[serde(rename_all = "camelCase")]
5347 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
5348 {
5349 pub key: String,
5350 pub operator: String,
5351 pub values: Vec<String>,
5352 }
5353
5354 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5355 #[serde(rename_all = "camelCase")]
5356 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
5357 {
5358 pub key: String,
5359 pub operator: String,
5360 pub values: Vec<String>,
5361 }
5362
5363 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5364 #[serde(rename_all = "camelCase")]
5365 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
5366 {
5367 pub key: String,
5368 pub operator: String,
5369 pub values: Vec<String>,
5370 }
5371
5372 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5373 #[serde(rename_all = "camelCase")]
5374 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
5375 {
5376 pub key: String,
5377 pub operator: String,
5378 pub values: Vec<String>,
5379 }
5380
5381 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5382 #[serde(rename_all = "camelCase")]
5383 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
5384 {
5385 pub key: String,
5386 pub operator: String,
5387 pub values: Vec<String>,
5388 }
5389
5390 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5391 #[serde(rename_all = "camelCase")]
5392 pub struct TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem {
5393 pub key: String,
5394 pub operator: String,
5395 pub values: Vec<String>,
5396 }
5397
5398 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5399 #[serde(rename_all = "camelCase")]
5400 pub struct PreferenceMatchFieldsItem {
5401 pub key: String,
5402 pub operator: String,
5403 pub values: Vec<String>,
5404 }
5405
5406 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5407 #[serde(rename_all = "camelCase")]
5408 pub struct NodeSelectorTermsItemMatchFieldsItem {
5409 pub key: String,
5410 pub operator: String,
5411 pub values: Vec<String>,
5412 }
5413
5414 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5415 #[serde(rename_all = "camelCase")]
5416 pub struct SelectorMatchLabels {
5417 pub properties: std::collections::HashMap<String, String>,
5418 }
5419
5420 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5421 #[serde(rename_all = "camelCase")]
5422 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
5423 {
5424 pub properties: std::collections::HashMap<String, String>,
5425 }
5426
5427 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5428 #[serde(rename_all = "camelCase")]
5429 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
5430 {
5431 pub properties: std::collections::HashMap<String, String>,
5432 }
5433
5434 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5435 #[serde(rename_all = "camelCase")]
5436 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels {
5437 pub properties: std::collections::HashMap<String, String>,
5438 }
5439
5440 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5441 #[serde(rename_all = "camelCase")]
5442 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
5443 {
5444 pub properties: std::collections::HashMap<String, String>,
5445 }
5446
5447 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5448 #[serde(rename_all = "camelCase")]
5449 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
5450 {
5451 pub properties: std::collections::HashMap<String, String>,
5452 }
5453
5454 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5455 #[serde(rename_all = "camelCase")]
5456 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
5457 {
5458 pub properties: std::collections::HashMap<String, String>,
5459 }
5460
5461 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5462 #[serde(rename_all = "camelCase")]
5463 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels
5464 {
5465 pub properties: std::collections::HashMap<String, String>,
5466 }
5467
5468 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5469 #[serde(rename_all = "camelCase")]
5470 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
5471 {
5472 pub properties: std::collections::HashMap<String, String>,
5473 }
5474
5475 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5476 #[serde(rename_all = "camelCase")]
5477 pub struct TopologySpreadConstraintsItemLabelSelectorMatchLabels {
5478 pub properties: std::collections::HashMap<String, String>,
5479 }
5480
5481 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5482 #[serde(rename_all = "camelCase")]
5483 pub struct MeasurementRetentionItem {
5484 pub limit: i32,
5485 pub metric_name: String,
5486 }
5487
5488 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5489 #[serde(rename_all = "camelCase")]
5490 pub struct JobMetadata {
5491 pub annotations: JobMetadataAnnotations,
5492 pub labels: JobMetadataLabels,
5493 }
5494
5495 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5496 #[serde(rename_all = "camelCase")]
5497 pub struct TemplateMetadata {
5498 pub annotations: TemplateMetadataAnnotations,
5499 pub labels: TemplateMetadataLabels,
5500 }
5501
5502 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5503 #[serde(rename_all = "camelCase")]
5504 pub struct Metric {
5505 pub dimensions: Vec<DimensionsItem>,
5506 pub metric_name: String,
5507 pub namespace: String,
5508 }
5509
5510 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5511 #[serde(rename_all = "camelCase")]
5512 pub struct MetricDataQueriesItem {
5513 pub expression: String,
5514 pub id: String,
5515 pub label: String,
5516 pub metric_stat: MetricStat,
5517 pub period: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5518 pub return_data: bool,
5519 }
5520
5521 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5522 #[serde(rename_all = "camelCase")]
5523 pub struct MetricStat {
5524 pub metric: Metric,
5525 pub period: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5526 pub stat: String,
5527 pub unit: String,
5528 }
5529
5530 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5531 #[serde(rename_all = "camelCase")]
5532 pub struct MetricsItem {
5533 pub consecutive_error_limit:
5534 k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5535 pub count: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5536 pub failure_condition: String,
5537 pub failure_limit: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5538 pub inconclusive_limit: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5539 pub initial_delay: String,
5540 pub interval: String,
5541 pub name: String,
5542 pub provider: Provider,
5543 pub success_condition: String,
5544 }
5545
5546 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5547 #[serde(rename_all = "camelCase")]
5548 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
5549 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
5550 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
5551 }
5552
5553 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5554 #[serde(rename_all = "camelCase")]
5555 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
5556 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
5557 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
5558 }
5559
5560 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5561 #[serde(rename_all = "camelCase")]
5562 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
5563 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
5564 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
5565 }
5566
5567 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5568 #[serde(rename_all = "camelCase")]
5569 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
5570 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
5571 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
5572 }
5573
5574 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5575 #[serde(rename_all = "camelCase")]
5576 pub struct NewRelic {
5577 pub profile: String,
5578 pub query: String,
5579 }
5580
5581 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5582 #[serde(rename_all = "camelCase")]
5583 pub struct NodeAffinity {
5584 pub preferred_during_scheduling_ignored_during_execution:
5585 Vec<NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
5586 pub required_during_scheduling_ignored_during_execution:
5587 RequiredDuringSchedulingIgnoredDuringExecution,
5588 }
5589
5590 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5591 #[serde(rename_all = "camelCase")]
5592 pub struct NodeSelector {
5593 pub properties: std::collections::HashMap<String, String>,
5594 }
5595
5596 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5597 #[serde(rename_all = "camelCase")]
5598 pub struct NodeSelectorTermsItem {
5599 pub match_expressions: Vec<NodeSelectorTermsItemMatchExpressionsItem>,
5600 pub match_fields: Vec<NodeSelectorTermsItemMatchFieldsItem>,
5601 }
5602
5603 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5604 #[serde(rename_all = "camelCase")]
5605 pub struct OptionsItem {
5606 pub name: String,
5607 pub value: String,
5608 }
5609
5610 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5611 #[serde(rename_all = "camelCase")]
5612 pub struct Os {
5613 pub name: String,
5614 }
5615
5616 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5617 #[serde(rename_all = "camelCase")]
5618 pub struct Overhead {
5619 pub properties: std::collections::HashMap<
5620 String,
5621 k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5622 >,
5623 }
5624
5625 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5626 #[serde(rename_all = "camelCase")]
5627 pub struct PodAffinity {
5628 pub preferred_during_scheduling_ignored_during_execution:
5629 Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
5630 pub required_during_scheduling_ignored_during_execution:
5631 Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
5632 }
5633
5634 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5635 #[serde(rename_all = "camelCase")]
5636 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
5637 pub label_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
5638 pub namespace_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
5639 pub namespaces: Vec<String>,
5640 pub topology_key: String,
5641 }
5642
5643 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5644 #[serde(rename_all = "camelCase")]
5645 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
5646 pub label_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
5647 pub namespace_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
5648 pub namespaces: Vec<String>,
5649 pub topology_key: String,
5650 }
5651
5652 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5653 #[serde(rename_all = "camelCase")]
5654 pub struct PodAntiAffinity {
5655 pub preferred_during_scheduling_ignored_during_execution:
5656 Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
5657 pub required_during_scheduling_ignored_during_execution:
5658 Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
5659 }
5660
5661 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5662 #[serde(rename_all = "camelCase")]
5663 pub struct ContainersItemPortsItem {
5664 pub container_port: i32,
5665 pub host_i_p: String,
5666 pub host_port: i32,
5667 pub name: String,
5668 pub protocol: String,
5669 }
5670
5671 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5672 #[serde(rename_all = "camelCase")]
5673 pub struct EphemeralContainersItemPortsItem {
5674 pub container_port: i32,
5675 pub host_i_p: String,
5676 pub host_port: i32,
5677 pub name: String,
5678 pub protocol: String,
5679 }
5680
5681 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5682 #[serde(rename_all = "camelCase")]
5683 pub struct InitContainersItemPortsItem {
5684 pub container_port: i32,
5685 pub host_i_p: String,
5686 pub host_port: i32,
5687 pub name: String,
5688 pub protocol: String,
5689 }
5690
5691 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5692 #[serde(rename_all = "camelCase")]
5693 pub struct ContainersItemLifecyclePostStart {
5694 pub exec: ContainersItemLifecyclePostStartExec,
5695 pub http_get: ContainersItemLifecyclePostStartHttpGet,
5696 pub tcp_socket: ContainersItemLifecyclePostStartTcpSocket,
5697 }
5698
5699 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5700 #[serde(rename_all = "camelCase")]
5701 pub struct EphemeralContainersItemLifecyclePostStart {
5702 pub exec: EphemeralContainersItemLifecyclePostStartExec,
5703 pub http_get: EphemeralContainersItemLifecyclePostStartHttpGet,
5704 pub tcp_socket: EphemeralContainersItemLifecyclePostStartTcpSocket,
5705 }
5706
5707 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5708 #[serde(rename_all = "camelCase")]
5709 pub struct InitContainersItemLifecyclePostStart {
5710 pub exec: InitContainersItemLifecyclePostStartExec,
5711 pub http_get: InitContainersItemLifecyclePostStartHttpGet,
5712 pub tcp_socket: InitContainersItemLifecyclePostStartTcpSocket,
5713 }
5714
5715 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5716 #[serde(rename_all = "camelCase")]
5717 pub struct ContainersItemLifecyclePreStop {
5718 pub exec: ContainersItemLifecyclePreStopExec,
5719 pub http_get: ContainersItemLifecyclePreStopHttpGet,
5720 pub tcp_socket: ContainersItemLifecyclePreStopTcpSocket,
5721 }
5722
5723 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5724 #[serde(rename_all = "camelCase")]
5725 pub struct EphemeralContainersItemLifecyclePreStop {
5726 pub exec: EphemeralContainersItemLifecyclePreStopExec,
5727 pub http_get: EphemeralContainersItemLifecyclePreStopHttpGet,
5728 pub tcp_socket: EphemeralContainersItemLifecyclePreStopTcpSocket,
5729 }
5730
5731 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5732 #[serde(rename_all = "camelCase")]
5733 pub struct InitContainersItemLifecyclePreStop {
5734 pub exec: InitContainersItemLifecyclePreStopExec,
5735 pub http_get: InitContainersItemLifecyclePreStopHttpGet,
5736 pub tcp_socket: InitContainersItemLifecyclePreStopTcpSocket,
5737 }
5738
5739 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5740 #[serde(rename_all = "camelCase")]
5741 pub struct Preference {
5742 pub match_expressions: Vec<PreferenceMatchExpressionsItem>,
5743 pub match_fields: Vec<PreferenceMatchFieldsItem>,
5744 }
5745
5746 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5747 #[serde(rename_all = "camelCase")]
5748 pub struct NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
5749 pub preference: Preference,
5750 pub weight: i32,
5751 }
5752
5753 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5754 #[serde(rename_all = "camelCase")]
5755 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
5756 pub pod_affinity_term:
5757 PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
5758 pub weight: i32,
5759 }
5760
5761 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5762 #[serde(rename_all = "camelCase")]
5763 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
5764 pub pod_affinity_term: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
5765 pub weight: i32,
5766 }
5767
5768 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5769 #[serde(rename_all = "camelCase")]
5770 pub struct Prometheus {
5771 pub address: String,
5772 pub query: String,
5773 }
5774
5775 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5776 #[serde(rename_all = "camelCase")]
5777 pub struct Provider {
5778 pub cloud_watch: CloudWatch,
5779 pub datadog: Datadog,
5780 pub graphite: Graphite,
5781 pub influxdb: Influxdb,
5782 pub job: Job,
5783 pub kayenta: Kayenta,
5784 pub new_relic: NewRelic,
5785 pub prometheus: Prometheus,
5786 pub wavefront: Wavefront,
5787 pub web: Web,
5788 }
5789
5790 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5791 #[serde(rename_all = "camelCase")]
5792 pub struct ReadinessGatesItem {
5793 pub condition_type: String,
5794 }
5795
5796 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5797 #[serde(rename_all = "camelCase")]
5798 pub struct ContainersItemReadinessProbe {
5799 pub exec: ContainersItemReadinessProbeExec,
5800 pub failure_threshold: i32,
5801 pub grpc: ContainersItemReadinessProbeGrpc,
5802 pub http_get: ContainersItemReadinessProbeHttpGet,
5803 pub initial_delay_seconds: i32,
5804 pub period_seconds: i32,
5805 pub success_threshold: i32,
5806 pub tcp_socket: ContainersItemReadinessProbeTcpSocket,
5807 pub termination_grace_period_seconds: i64,
5808 pub timeout_seconds: i32,
5809 }
5810
5811 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5812 #[serde(rename_all = "camelCase")]
5813 pub struct EphemeralContainersItemReadinessProbe {
5814 pub exec: EphemeralContainersItemReadinessProbeExec,
5815 pub failure_threshold: i32,
5816 pub grpc: EphemeralContainersItemReadinessProbeGrpc,
5817 pub http_get: EphemeralContainersItemReadinessProbeHttpGet,
5818 pub initial_delay_seconds: i32,
5819 pub period_seconds: i32,
5820 pub success_threshold: i32,
5821 pub tcp_socket: EphemeralContainersItemReadinessProbeTcpSocket,
5822 pub termination_grace_period_seconds: i64,
5823 pub timeout_seconds: i32,
5824 }
5825
5826 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5827 #[serde(rename_all = "camelCase")]
5828 pub struct InitContainersItemReadinessProbe {
5829 pub exec: InitContainersItemReadinessProbeExec,
5830 pub failure_threshold: i32,
5831 pub grpc: InitContainersItemReadinessProbeGrpc,
5832 pub http_get: InitContainersItemReadinessProbeHttpGet,
5833 pub initial_delay_seconds: i32,
5834 pub period_seconds: i32,
5835 pub success_threshold: i32,
5836 pub tcp_socket: InitContainersItemReadinessProbeTcpSocket,
5837 pub termination_grace_period_seconds: i64,
5838 pub timeout_seconds: i32,
5839 }
5840
5841 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5842 #[serde(rename_all = "camelCase")]
5843 pub struct RequiredDuringSchedulingIgnoredDuringExecution {
5844 pub node_selector_terms: Vec<NodeSelectorTermsItem>,
5845 }
5846
5847 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5848 #[serde(rename_all = "camelCase")]
5849 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
5850 pub label_selector:
5851 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
5852 pub namespace_selector:
5853 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
5854 pub namespaces: Vec<String>,
5855 pub topology_key: String,
5856 }
5857
5858 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5859 #[serde(rename_all = "camelCase")]
5860 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
5861 pub label_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
5862 pub namespace_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
5863 pub namespaces: Vec<String>,
5864 pub topology_key: String,
5865 }
5866
5867 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5868 #[serde(rename_all = "camelCase")]
5869 pub struct ContainersItemEnvItemValueFromResourceFieldRef {
5870 pub container_name: String,
5871 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5872 pub resource: String,
5873 }
5874
5875 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5876 #[serde(rename_all = "camelCase")]
5877 pub struct EphemeralContainersItemEnvItemValueFromResourceFieldRef {
5878 pub container_name: String,
5879 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5880 pub resource: String,
5881 }
5882
5883 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5884 #[serde(rename_all = "camelCase")]
5885 pub struct InitContainersItemEnvItemValueFromResourceFieldRef {
5886 pub container_name: String,
5887 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
5888 pub resource: String,
5889 }
5890
5891 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5892 #[serde(rename_all = "camelCase")]
5893 pub struct ContainersItemResources {
5894 pub limits: serde_json::Map<String, serde_json::Value>,
5895 pub requests: serde_json::Map<String, serde_json::Value>,
5896 }
5897
5898 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5899 #[serde(rename_all = "camelCase")]
5900 pub struct EphemeralContainersItemResources {
5901 pub limits: serde_json::Map<String, serde_json::Value>,
5902 pub requests: serde_json::Map<String, serde_json::Value>,
5903 }
5904
5905 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5906 #[serde(rename_all = "camelCase")]
5907 pub struct InitContainersItemResources {
5908 pub limits: serde_json::Map<String, serde_json::Value>,
5909 pub requests: serde_json::Map<String, serde_json::Value>,
5910 }
5911
5912 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5913 #[serde(rename_all = "camelCase")]
5914 pub struct ScopesItem {
5915 pub control_scope: ControlScope,
5916 pub experiment_scope: ExperimentScope,
5917 pub name: String,
5918 }
5919
5920 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5921 #[serde(rename_all = "camelCase")]
5922 pub struct ContainersItemSecurityContextSeLinuxOptions {
5923 pub level: String,
5924 pub role: String,
5925 pub r#type: String,
5926 pub user: String,
5927 }
5928
5929 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5930 #[serde(rename_all = "camelCase")]
5931 pub struct EphemeralContainersItemSecurityContextSeLinuxOptions {
5932 pub level: String,
5933 pub role: String,
5934 pub r#type: String,
5935 pub user: String,
5936 }
5937
5938 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5939 #[serde(rename_all = "camelCase")]
5940 pub struct InitContainersItemSecurityContextSeLinuxOptions {
5941 pub level: String,
5942 pub role: String,
5943 pub r#type: String,
5944 pub user: String,
5945 }
5946
5947 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5948 #[serde(rename_all = "camelCase")]
5949 pub struct SpecSecurityContextSeLinuxOptions {
5950 pub level: String,
5951 pub role: String,
5952 pub r#type: String,
5953 pub user: String,
5954 }
5955
5956 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5957 #[serde(rename_all = "camelCase")]
5958 pub struct ContainersItemSecurityContextSeccompProfile {
5959 pub localhost_profile: String,
5960 pub r#type: String,
5961 }
5962
5963 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5964 #[serde(rename_all = "camelCase")]
5965 pub struct EphemeralContainersItemSecurityContextSeccompProfile {
5966 pub localhost_profile: String,
5967 pub r#type: String,
5968 }
5969
5970 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5971 #[serde(rename_all = "camelCase")]
5972 pub struct InitContainersItemSecurityContextSeccompProfile {
5973 pub localhost_profile: String,
5974 pub r#type: String,
5975 }
5976
5977 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5978 #[serde(rename_all = "camelCase")]
5979 pub struct SpecSecurityContextSeccompProfile {
5980 pub localhost_profile: String,
5981 pub r#type: String,
5982 }
5983
5984 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5985 #[serde(rename_all = "camelCase")]
5986 pub struct ArgsItemValueFromSecretKeyRef {
5987 pub key: String,
5988 pub name: String,
5989 }
5990
5991 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
5992 #[serde(rename_all = "camelCase")]
5993 pub struct ContainersItemEnvItemValueFromSecretKeyRef {
5994 pub key: String,
5995 pub name: String,
5996 pub optional: bool,
5997 }
5998
5999 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6000 #[serde(rename_all = "camelCase")]
6001 pub struct EphemeralContainersItemEnvItemValueFromSecretKeyRef {
6002 pub key: String,
6003 pub name: String,
6004 pub optional: bool,
6005 }
6006
6007 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6008 #[serde(rename_all = "camelCase")]
6009 pub struct InitContainersItemEnvItemValueFromSecretKeyRef {
6010 pub key: String,
6011 pub name: String,
6012 pub optional: bool,
6013 }
6014
6015 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6016 #[serde(rename_all = "camelCase")]
6017 pub struct ContainersItemEnvFromItemSecretRef {
6018 pub name: String,
6019 pub optional: bool,
6020 }
6021
6022 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6023 #[serde(rename_all = "camelCase")]
6024 pub struct EphemeralContainersItemEnvFromItemSecretRef {
6025 pub name: String,
6026 pub optional: bool,
6027 }
6028
6029 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6030 #[serde(rename_all = "camelCase")]
6031 pub struct InitContainersItemEnvFromItemSecretRef {
6032 pub name: String,
6033 pub optional: bool,
6034 }
6035
6036 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6037 #[serde(rename_all = "camelCase")]
6038 pub struct SpecSecurityContext {
6039 pub fs_group: i64,
6040 pub fs_group_change_policy: String,
6041 pub run_as_group: i64,
6042 pub run_as_non_root: bool,
6043 pub run_as_user: i64,
6044 pub se_linux_options: SpecSecurityContextSeLinuxOptions,
6045 pub seccomp_profile: SpecSecurityContextSeccompProfile,
6046 pub supplemental_groups: Vec<i64>,
6047 pub sysctls: Vec<SysctlsItem>,
6048 pub windows_options: SpecSecurityContextWindowsOptions,
6049 }
6050
6051 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6052 #[serde(rename_all = "camelCase")]
6053 pub struct ContainersItemSecurityContext {
6054 pub allow_privilege_escalation: bool,
6055 pub capabilities: ContainersItemSecurityContextCapabilities,
6056 pub privileged: bool,
6057 pub proc_mount: String,
6058 pub read_only_root_filesystem: bool,
6059 pub run_as_group: i64,
6060 pub run_as_non_root: bool,
6061 pub run_as_user: i64,
6062 pub se_linux_options: ContainersItemSecurityContextSeLinuxOptions,
6063 pub seccomp_profile: ContainersItemSecurityContextSeccompProfile,
6064 pub windows_options: ContainersItemSecurityContextWindowsOptions,
6065 }
6066
6067 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6068 #[serde(rename_all = "camelCase")]
6069 pub struct EphemeralContainersItemSecurityContext {
6070 pub allow_privilege_escalation: bool,
6071 pub capabilities: EphemeralContainersItemSecurityContextCapabilities,
6072 pub privileged: bool,
6073 pub proc_mount: String,
6074 pub read_only_root_filesystem: bool,
6075 pub run_as_group: i64,
6076 pub run_as_non_root: bool,
6077 pub run_as_user: i64,
6078 pub se_linux_options: EphemeralContainersItemSecurityContextSeLinuxOptions,
6079 pub seccomp_profile: EphemeralContainersItemSecurityContextSeccompProfile,
6080 pub windows_options: EphemeralContainersItemSecurityContextWindowsOptions,
6081 }
6082
6083 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6084 #[serde(rename_all = "camelCase")]
6085 pub struct InitContainersItemSecurityContext {
6086 pub allow_privilege_escalation: bool,
6087 pub capabilities: InitContainersItemSecurityContextCapabilities,
6088 pub privileged: bool,
6089 pub proc_mount: String,
6090 pub read_only_root_filesystem: bool,
6091 pub run_as_group: i64,
6092 pub run_as_non_root: bool,
6093 pub run_as_user: i64,
6094 pub se_linux_options: InitContainersItemSecurityContextSeLinuxOptions,
6095 pub seccomp_profile: InitContainersItemSecurityContextSeccompProfile,
6096 pub windows_options: InitContainersItemSecurityContextWindowsOptions,
6097 }
6098
6099 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6100 #[serde(rename_all = "camelCase")]
6101 pub struct Selector {
6102 pub match_expressions: Vec<SelectorMatchExpressionsItem>,
6103 pub match_labels: SelectorMatchLabels,
6104 }
6105
6106 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6107 #[serde(rename_all = "camelCase")]
6108 pub struct Spec {
6109 pub args: Vec<ArgsItem>,
6110 pub dry_run: Vec<DryRunItem>,
6111 pub measurement_retention: Vec<MeasurementRetentionItem>,
6112 pub metrics: Vec<MetricsItem>,
6113 }
6114
6115 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6116 #[serde(rename_all = "camelCase")]
6117 pub struct JobSpec {
6118 pub active_deadline_seconds: i64,
6119 pub backoff_limit: i32,
6120 pub completion_mode: String,
6121 pub completions: i32,
6122 pub manual_selector: bool,
6123 pub parallelism: i32,
6124 pub selector: Selector,
6125 pub suspend: bool,
6126 pub template: Template,
6127 pub ttl_seconds_after_finished: i32,
6128 }
6129
6130 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6131 #[serde(rename_all = "camelCase")]
6132 pub struct TemplateSpec {
6133 pub active_deadline_seconds: i64,
6134 pub affinity: Affinity,
6135 pub automount_service_account_token: bool,
6136 pub containers: Vec<ContainersItem>,
6137 pub dns_config: DnsConfig,
6138 pub dns_policy: String,
6139 pub enable_service_links: bool,
6140 pub ephemeral_containers: Vec<EphemeralContainersItem>,
6141 pub host_aliases: Vec<HostAliasesItem>,
6142 pub host_i_p_c: bool,
6143 pub host_network: bool,
6144 pub host_p_i_d: bool,
6145 pub hostname: String,
6146 pub image_pull_secrets: Vec<ImagePullSecretsItem>,
6147 pub init_containers: Vec<InitContainersItem>,
6148 pub node_name: String,
6149 pub node_selector: NodeSelector,
6150 pub os: Os,
6151 pub overhead: Overhead,
6152 pub preemption_policy: String,
6153 pub priority: i32,
6154 pub priority_class_name: String,
6155 pub readiness_gates: Vec<ReadinessGatesItem>,
6156 pub restart_policy: String,
6157 pub runtime_class_name: String,
6158 pub scheduler_name: String,
6159 pub security_context: SpecSecurityContext,
6160 pub service_account: String,
6161 pub service_account_name: String,
6162 pub set_hostname_as_f_q_d_n: bool,
6163 pub share_process_namespace: bool,
6164 pub subdomain: String,
6165 pub termination_grace_period_seconds: i64,
6166 pub tolerations: Vec<TolerationsItem>,
6167 pub topology_spread_constraints: Vec<TopologySpreadConstraintsItem>,
6168 pub volumes: serde_json::Map<String, serde_json::Value>,
6169 }
6170
6171 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6172 #[serde(rename_all = "camelCase")]
6173 pub struct ContainersItemStartupProbe {
6174 pub exec: ContainersItemStartupProbeExec,
6175 pub failure_threshold: i32,
6176 pub grpc: ContainersItemStartupProbeGrpc,
6177 pub http_get: ContainersItemStartupProbeHttpGet,
6178 pub initial_delay_seconds: i32,
6179 pub period_seconds: i32,
6180 pub success_threshold: i32,
6181 pub tcp_socket: ContainersItemStartupProbeTcpSocket,
6182 pub termination_grace_period_seconds: i64,
6183 pub timeout_seconds: i32,
6184 }
6185
6186 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6187 #[serde(rename_all = "camelCase")]
6188 pub struct EphemeralContainersItemStartupProbe {
6189 pub exec: EphemeralContainersItemStartupProbeExec,
6190 pub failure_threshold: i32,
6191 pub grpc: EphemeralContainersItemStartupProbeGrpc,
6192 pub http_get: EphemeralContainersItemStartupProbeHttpGet,
6193 pub initial_delay_seconds: i32,
6194 pub period_seconds: i32,
6195 pub success_threshold: i32,
6196 pub tcp_socket: EphemeralContainersItemStartupProbeTcpSocket,
6197 pub termination_grace_period_seconds: i64,
6198 pub timeout_seconds: i32,
6199 }
6200
6201 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6202 #[serde(rename_all = "camelCase")]
6203 pub struct InitContainersItemStartupProbe {
6204 pub exec: InitContainersItemStartupProbeExec,
6205 pub failure_threshold: i32,
6206 pub grpc: InitContainersItemStartupProbeGrpc,
6207 pub http_get: InitContainersItemStartupProbeHttpGet,
6208 pub initial_delay_seconds: i32,
6209 pub period_seconds: i32,
6210 pub success_threshold: i32,
6211 pub tcp_socket: InitContainersItemStartupProbeTcpSocket,
6212 pub termination_grace_period_seconds: i64,
6213 pub timeout_seconds: i32,
6214 }
6215
6216 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6217 #[serde(rename_all = "camelCase")]
6218 pub struct SysctlsItem {
6219 pub name: String,
6220 pub value: String,
6221 }
6222
6223 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6224 #[serde(rename_all = "camelCase")]
6225 pub struct ContainersItemLifecyclePostStartTcpSocket {
6226 pub host: String,
6227 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6228 }
6229
6230 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6231 #[serde(rename_all = "camelCase")]
6232 pub struct ContainersItemLifecyclePreStopTcpSocket {
6233 pub host: String,
6234 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6235 }
6236
6237 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6238 #[serde(rename_all = "camelCase")]
6239 pub struct ContainersItemLivenessProbeTcpSocket {
6240 pub host: String,
6241 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6242 }
6243
6244 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6245 #[serde(rename_all = "camelCase")]
6246 pub struct ContainersItemReadinessProbeTcpSocket {
6247 pub host: String,
6248 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6249 }
6250
6251 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6252 #[serde(rename_all = "camelCase")]
6253 pub struct ContainersItemStartupProbeTcpSocket {
6254 pub host: String,
6255 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6256 }
6257
6258 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6259 #[serde(rename_all = "camelCase")]
6260 pub struct EphemeralContainersItemLifecyclePostStartTcpSocket {
6261 pub host: String,
6262 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6263 }
6264
6265 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6266 #[serde(rename_all = "camelCase")]
6267 pub struct EphemeralContainersItemLifecyclePreStopTcpSocket {
6268 pub host: String,
6269 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6270 }
6271
6272 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6273 #[serde(rename_all = "camelCase")]
6274 pub struct EphemeralContainersItemLivenessProbeTcpSocket {
6275 pub host: String,
6276 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6277 }
6278
6279 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6280 #[serde(rename_all = "camelCase")]
6281 pub struct EphemeralContainersItemReadinessProbeTcpSocket {
6282 pub host: String,
6283 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6284 }
6285
6286 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6287 #[serde(rename_all = "camelCase")]
6288 pub struct EphemeralContainersItemStartupProbeTcpSocket {
6289 pub host: String,
6290 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6291 }
6292
6293 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6294 #[serde(rename_all = "camelCase")]
6295 pub struct InitContainersItemLifecyclePostStartTcpSocket {
6296 pub host: String,
6297 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6298 }
6299
6300 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6301 #[serde(rename_all = "camelCase")]
6302 pub struct InitContainersItemLifecyclePreStopTcpSocket {
6303 pub host: String,
6304 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6305 }
6306
6307 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6308 #[serde(rename_all = "camelCase")]
6309 pub struct InitContainersItemLivenessProbeTcpSocket {
6310 pub host: String,
6311 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6312 }
6313
6314 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6315 #[serde(rename_all = "camelCase")]
6316 pub struct InitContainersItemReadinessProbeTcpSocket {
6317 pub host: String,
6318 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6319 }
6320
6321 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6322 #[serde(rename_all = "camelCase")]
6323 pub struct InitContainersItemStartupProbeTcpSocket {
6324 pub host: String,
6325 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6326 }
6327
6328 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6329 #[serde(rename_all = "camelCase")]
6330 pub struct Template {
6331 pub metadata: TemplateMetadata,
6332 pub spec: TemplateSpec,
6333 }
6334
6335 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6336 #[serde(rename_all = "camelCase")]
6337 pub struct Threshold {
6338 pub marginal: i64,
6339 pub pass: i64,
6340 }
6341
6342 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6343 #[serde(rename_all = "camelCase")]
6344 pub struct TolerationsItem {
6345 pub effect: String,
6346 pub key: String,
6347 pub operator: String,
6348 pub toleration_seconds: i64,
6349 pub value: String,
6350 }
6351
6352 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6353 #[serde(rename_all = "camelCase")]
6354 pub struct TopologySpreadConstraintsItem {
6355 pub label_selector: TopologySpreadConstraintsItemLabelSelector,
6356 pub max_skew: i32,
6357 pub topology_key: String,
6358 pub when_unsatisfiable: String,
6359 }
6360
6361 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6362 #[serde(rename_all = "camelCase")]
6363 pub struct ArgsItemValueFrom {
6364 pub field_ref: ArgsItemValueFromFieldRef,
6365 pub secret_key_ref: ArgsItemValueFromSecretKeyRef,
6366 }
6367
6368 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6369 #[serde(rename_all = "camelCase")]
6370 pub struct ContainersItemEnvItemValueFrom {
6371 pub config_map_key_ref: ContainersItemEnvItemValueFromConfigMapKeyRef,
6372 pub field_ref: ContainersItemEnvItemValueFromFieldRef,
6373 pub resource_field_ref: ContainersItemEnvItemValueFromResourceFieldRef,
6374 pub secret_key_ref: ContainersItemEnvItemValueFromSecretKeyRef,
6375 }
6376
6377 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6378 #[serde(rename_all = "camelCase")]
6379 pub struct EphemeralContainersItemEnvItemValueFrom {
6380 pub config_map_key_ref: EphemeralContainersItemEnvItemValueFromConfigMapKeyRef,
6381 pub field_ref: EphemeralContainersItemEnvItemValueFromFieldRef,
6382 pub resource_field_ref: EphemeralContainersItemEnvItemValueFromResourceFieldRef,
6383 pub secret_key_ref: EphemeralContainersItemEnvItemValueFromSecretKeyRef,
6384 }
6385
6386 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6387 #[serde(rename_all = "camelCase")]
6388 pub struct InitContainersItemEnvItemValueFrom {
6389 pub config_map_key_ref: InitContainersItemEnvItemValueFromConfigMapKeyRef,
6390 pub field_ref: InitContainersItemEnvItemValueFromFieldRef,
6391 pub resource_field_ref: InitContainersItemEnvItemValueFromResourceFieldRef,
6392 pub secret_key_ref: InitContainersItemEnvItemValueFromSecretKeyRef,
6393 }
6394
6395 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6396 #[serde(rename_all = "camelCase")]
6397 pub struct ContainersItemVolumeDevicesItem {
6398 pub device_path: String,
6399 pub name: String,
6400 }
6401
6402 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6403 #[serde(rename_all = "camelCase")]
6404 pub struct EphemeralContainersItemVolumeDevicesItem {
6405 pub device_path: String,
6406 pub name: String,
6407 }
6408
6409 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6410 #[serde(rename_all = "camelCase")]
6411 pub struct InitContainersItemVolumeDevicesItem {
6412 pub device_path: String,
6413 pub name: String,
6414 }
6415
6416 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6417 #[serde(rename_all = "camelCase")]
6418 pub struct ContainersItemVolumeMountsItem {
6419 pub mount_path: String,
6420 pub mount_propagation: String,
6421 pub name: String,
6422 pub read_only: bool,
6423 pub sub_path: String,
6424 pub sub_path_expr: String,
6425 }
6426
6427 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6428 #[serde(rename_all = "camelCase")]
6429 pub struct EphemeralContainersItemVolumeMountsItem {
6430 pub mount_path: String,
6431 pub mount_propagation: String,
6432 pub name: String,
6433 pub read_only: bool,
6434 pub sub_path: String,
6435 pub sub_path_expr: String,
6436 }
6437
6438 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6439 #[serde(rename_all = "camelCase")]
6440 pub struct InitContainersItemVolumeMountsItem {
6441 pub mount_path: String,
6442 pub mount_propagation: String,
6443 pub name: String,
6444 pub read_only: bool,
6445 pub sub_path: String,
6446 pub sub_path_expr: String,
6447 }
6448
6449 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6450 #[serde(rename_all = "camelCase")]
6451 pub struct Wavefront {
6452 pub address: String,
6453 pub query: String,
6454 }
6455
6456 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6457 #[serde(rename_all = "camelCase")]
6458 pub struct Web {
6459 pub body: String,
6460 pub headers: Vec<HeadersItem>,
6461 pub insecure: bool,
6462 pub json_path: String,
6463 pub method: String,
6464 pub timeout_seconds: i64,
6465 pub url: String,
6466 }
6467
6468 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6469 #[serde(rename_all = "camelCase")]
6470 pub struct ContainersItemSecurityContextWindowsOptions {
6471 pub gmsa_credential_spec: String,
6472 pub gmsa_credential_spec_name: String,
6473 pub host_process: bool,
6474 pub run_as_user_name: String,
6475 }
6476
6477 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6478 #[serde(rename_all = "camelCase")]
6479 pub struct EphemeralContainersItemSecurityContextWindowsOptions {
6480 pub gmsa_credential_spec: String,
6481 pub gmsa_credential_spec_name: String,
6482 pub host_process: bool,
6483 pub run_as_user_name: String,
6484 }
6485
6486 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6487 #[serde(rename_all = "camelCase")]
6488 pub struct InitContainersItemSecurityContextWindowsOptions {
6489 pub gmsa_credential_spec: String,
6490 pub gmsa_credential_spec_name: String,
6491 pub host_process: bool,
6492 pub run_as_user_name: String,
6493 }
6494
6495 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6496 #[serde(rename_all = "camelCase")]
6497 pub struct SpecSecurityContextWindowsOptions {
6498 pub gmsa_credential_spec: String,
6499 pub gmsa_credential_spec_name: String,
6500 pub host_process: bool,
6501 pub run_as_user_name: String,
6502 }
6503 }
6504 pub mod experiment {
6505 #[derive(serde::Deserialize, Debug, PartialEq)]
6506 pub struct Experiment {
6507 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
6508 pub spec: Spec,
6509 pub status: Status,
6510 }
6511
6512 impl k8s_openapi::Resource for Experiment {
6513 type Scope = k8s_openapi::ClusterResourceScope;
6514
6515 const API_VERSION: &'static str = "argoproj.io/v1alpha1";
6516 const GROUP: &'static str = "argoproj.io";
6517 const KIND: &'static str = "Experiment";
6518 const VERSION: &'static str = "v1alpha1";
6519 const URL_PATH_SEGMENT: &'static str = "TODO";
6520 }
6521
6522 impl k8s_openapi::Metadata for Experiment {
6523 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
6524
6525 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
6526 &self.metadata
6527 }
6528
6529 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
6530 &mut self.metadata
6531 }
6532 }
6533
6534 impl serde::Serialize for Experiment {
6535 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
6536 where
6537 S: serde::Serializer,
6538 {
6539 use serde::ser::SerializeStruct;
6540 let mut state = serializer.serialize_struct("Experiment", 5)?;
6541 state.serialize_field(
6542 "apiVersion",
6543 <Self as k8s_openapi::Resource>::API_VERSION,
6544 )?;
6545 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
6546 state.serialize_field("metadata", &self.metadata)?;
6547 state.serialize_field("spec", &self.spec)?;
6548 state.serialize_field("status", &self.status)?;
6549 state.end()
6550 }
6551 }
6552
6553 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6554 #[serde(rename_all = "camelCase")]
6555 pub struct Affinity {
6556 pub node_affinity: NodeAffinity,
6557 pub pod_affinity: PodAffinity,
6558 pub pod_anti_affinity: PodAntiAffinity,
6559 }
6560
6561 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6562 #[serde(rename_all = "camelCase")]
6563 pub struct AnalysesItem {
6564 pub args: Vec<ArgsItem>,
6565 pub cluster_scope: bool,
6566 pub name: String,
6567 pub required_for_completion: bool,
6568 pub template_name: String,
6569 }
6570
6571 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6572 #[serde(rename_all = "camelCase")]
6573 pub struct AnalysisRunsItem {
6574 pub analysis_run: String,
6575 pub message: String,
6576 pub name: String,
6577 pub phase: String,
6578 }
6579
6580 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6581 #[serde(rename_all = "camelCase")]
6582 pub struct Annotations {
6583 pub properties: std::collections::HashMap<String, String>,
6584 }
6585
6586 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6587 #[serde(rename_all = "camelCase")]
6588 pub struct ArgsItem {
6589 pub name: String,
6590 pub value: String,
6591 pub value_from: ArgsItemValueFrom,
6592 }
6593
6594 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6595 #[serde(rename_all = "camelCase")]
6596 pub struct ContainersItemSecurityContextCapabilities {
6597 pub add: Vec<String>,
6598 pub drop: Vec<String>,
6599 }
6600
6601 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6602 #[serde(rename_all = "camelCase")]
6603 pub struct EphemeralContainersItemSecurityContextCapabilities {
6604 pub add: Vec<String>,
6605 pub drop: Vec<String>,
6606 }
6607
6608 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6609 #[serde(rename_all = "camelCase")]
6610 pub struct InitContainersItemSecurityContextCapabilities {
6611 pub add: Vec<String>,
6612 pub drop: Vec<String>,
6613 }
6614
6615 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6616 #[serde(rename_all = "camelCase")]
6617 pub struct ConditionsItem {
6618 pub last_transition_time: String,
6619 pub last_update_time: String,
6620 pub message: String,
6621 pub reason: String,
6622 pub status: String,
6623 pub r#type: String,
6624 }
6625
6626 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6627 #[serde(rename_all = "camelCase")]
6628 pub struct ContainersItemEnvItemValueFromConfigMapKeyRef {
6629 pub key: String,
6630 pub name: String,
6631 pub optional: bool,
6632 }
6633
6634 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6635 #[serde(rename_all = "camelCase")]
6636 pub struct EphemeralContainersItemEnvItemValueFromConfigMapKeyRef {
6637 pub key: String,
6638 pub name: String,
6639 pub optional: bool,
6640 }
6641
6642 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6643 #[serde(rename_all = "camelCase")]
6644 pub struct InitContainersItemEnvItemValueFromConfigMapKeyRef {
6645 pub key: String,
6646 pub name: String,
6647 pub optional: bool,
6648 }
6649
6650 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6651 #[serde(rename_all = "camelCase")]
6652 pub struct ContainersItemEnvFromItemConfigMapRef {
6653 pub name: String,
6654 pub optional: bool,
6655 }
6656
6657 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6658 #[serde(rename_all = "camelCase")]
6659 pub struct EphemeralContainersItemEnvFromItemConfigMapRef {
6660 pub name: String,
6661 pub optional: bool,
6662 }
6663
6664 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6665 #[serde(rename_all = "camelCase")]
6666 pub struct InitContainersItemEnvFromItemConfigMapRef {
6667 pub name: String,
6668 pub optional: bool,
6669 }
6670
6671 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6672 #[serde(rename_all = "camelCase")]
6673 pub struct ContainersItem {
6674 pub args: Vec<String>,
6675 pub command: Vec<String>,
6676 pub env: Vec<ContainersItemEnvItem>,
6677 pub env_from: Vec<ContainersItemEnvFromItem>,
6678 pub image: String,
6679 pub image_pull_policy: String,
6680 pub lifecycle: ContainersItemLifecycle,
6681 pub liveness_probe: ContainersItemLivenessProbe,
6682 pub name: String,
6683 pub ports: Vec<ContainersItemPortsItem>,
6684 pub readiness_probe: ContainersItemReadinessProbe,
6685 pub resources: ContainersItemResources,
6686 pub security_context: ContainersItemSecurityContext,
6687 pub startup_probe: ContainersItemStartupProbe,
6688 pub stdin: bool,
6689 pub stdin_once: bool,
6690 pub termination_message_path: String,
6691 pub termination_message_policy: String,
6692 pub tty: bool,
6693 pub volume_devices: Vec<ContainersItemVolumeDevicesItem>,
6694 pub volume_mounts: Vec<ContainersItemVolumeMountsItem>,
6695 pub working_dir: String,
6696 }
6697
6698 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6699 #[serde(rename_all = "camelCase")]
6700 pub struct DnsConfig {
6701 pub nameservers: Vec<String>,
6702 pub options: Vec<OptionsItem>,
6703 pub searches: Vec<String>,
6704 }
6705
6706 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6707 #[serde(rename_all = "camelCase")]
6708 pub struct DryRunItem {
6709 pub metric_name: String,
6710 }
6711
6712 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6713 #[serde(rename_all = "camelCase")]
6714 pub struct ContainersItemEnvFromItem {
6715 pub config_map_ref: ContainersItemEnvFromItemConfigMapRef,
6716 pub prefix: String,
6717 pub secret_ref: ContainersItemEnvFromItemSecretRef,
6718 }
6719
6720 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6721 #[serde(rename_all = "camelCase")]
6722 pub struct EphemeralContainersItemEnvFromItem {
6723 pub config_map_ref: EphemeralContainersItemEnvFromItemConfigMapRef,
6724 pub prefix: String,
6725 pub secret_ref: EphemeralContainersItemEnvFromItemSecretRef,
6726 }
6727
6728 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6729 #[serde(rename_all = "camelCase")]
6730 pub struct InitContainersItemEnvFromItem {
6731 pub config_map_ref: InitContainersItemEnvFromItemConfigMapRef,
6732 pub prefix: String,
6733 pub secret_ref: InitContainersItemEnvFromItemSecretRef,
6734 }
6735
6736 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6737 #[serde(rename_all = "camelCase")]
6738 pub struct ContainersItemEnvItem {
6739 pub name: String,
6740 pub value: String,
6741 pub value_from: ContainersItemEnvItemValueFrom,
6742 }
6743
6744 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6745 #[serde(rename_all = "camelCase")]
6746 pub struct EphemeralContainersItemEnvItem {
6747 pub name: String,
6748 pub value: String,
6749 pub value_from: EphemeralContainersItemEnvItemValueFrom,
6750 }
6751
6752 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6753 #[serde(rename_all = "camelCase")]
6754 pub struct InitContainersItemEnvItem {
6755 pub name: String,
6756 pub value: String,
6757 pub value_from: InitContainersItemEnvItemValueFrom,
6758 }
6759
6760 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6761 #[serde(rename_all = "camelCase")]
6762 pub struct EphemeralContainersItem {
6763 pub args: Vec<String>,
6764 pub command: Vec<String>,
6765 pub env: Vec<EphemeralContainersItemEnvItem>,
6766 pub env_from: Vec<EphemeralContainersItemEnvFromItem>,
6767 pub image: String,
6768 pub image_pull_policy: String,
6769 pub lifecycle: EphemeralContainersItemLifecycle,
6770 pub liveness_probe: EphemeralContainersItemLivenessProbe,
6771 pub name: String,
6772 pub ports: Vec<EphemeralContainersItemPortsItem>,
6773 pub readiness_probe: EphemeralContainersItemReadinessProbe,
6774 pub resources: EphemeralContainersItemResources,
6775 pub security_context: EphemeralContainersItemSecurityContext,
6776 pub startup_probe: EphemeralContainersItemStartupProbe,
6777 pub stdin: bool,
6778 pub stdin_once: bool,
6779 pub target_container_name: String,
6780 pub termination_message_path: String,
6781 pub termination_message_policy: String,
6782 pub tty: bool,
6783 pub volume_devices: Vec<EphemeralContainersItemVolumeDevicesItem>,
6784 pub volume_mounts: Vec<EphemeralContainersItemVolumeMountsItem>,
6785 pub working_dir: String,
6786 }
6787
6788 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6789 #[serde(rename_all = "camelCase")]
6790 pub struct ContainersItemLifecyclePostStartExec {
6791 pub command: Vec<String>,
6792 }
6793
6794 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6795 #[serde(rename_all = "camelCase")]
6796 pub struct ContainersItemLifecyclePreStopExec {
6797 pub command: Vec<String>,
6798 }
6799
6800 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6801 #[serde(rename_all = "camelCase")]
6802 pub struct ContainersItemLivenessProbeExec {
6803 pub command: Vec<String>,
6804 }
6805
6806 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6807 #[serde(rename_all = "camelCase")]
6808 pub struct ContainersItemReadinessProbeExec {
6809 pub command: Vec<String>,
6810 }
6811
6812 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6813 #[serde(rename_all = "camelCase")]
6814 pub struct ContainersItemStartupProbeExec {
6815 pub command: Vec<String>,
6816 }
6817
6818 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6819 #[serde(rename_all = "camelCase")]
6820 pub struct EphemeralContainersItemLifecyclePostStartExec {
6821 pub command: Vec<String>,
6822 }
6823
6824 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6825 #[serde(rename_all = "camelCase")]
6826 pub struct EphemeralContainersItemLifecyclePreStopExec {
6827 pub command: Vec<String>,
6828 }
6829
6830 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6831 #[serde(rename_all = "camelCase")]
6832 pub struct EphemeralContainersItemLivenessProbeExec {
6833 pub command: Vec<String>,
6834 }
6835
6836 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6837 #[serde(rename_all = "camelCase")]
6838 pub struct EphemeralContainersItemReadinessProbeExec {
6839 pub command: Vec<String>,
6840 }
6841
6842 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6843 #[serde(rename_all = "camelCase")]
6844 pub struct EphemeralContainersItemStartupProbeExec {
6845 pub command: Vec<String>,
6846 }
6847
6848 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6849 #[serde(rename_all = "camelCase")]
6850 pub struct InitContainersItemLifecyclePostStartExec {
6851 pub command: Vec<String>,
6852 }
6853
6854 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6855 #[serde(rename_all = "camelCase")]
6856 pub struct InitContainersItemLifecyclePreStopExec {
6857 pub command: Vec<String>,
6858 }
6859
6860 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6861 #[serde(rename_all = "camelCase")]
6862 pub struct InitContainersItemLivenessProbeExec {
6863 pub command: Vec<String>,
6864 }
6865
6866 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6867 #[serde(rename_all = "camelCase")]
6868 pub struct InitContainersItemReadinessProbeExec {
6869 pub command: Vec<String>,
6870 }
6871
6872 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6873 #[serde(rename_all = "camelCase")]
6874 pub struct InitContainersItemStartupProbeExec {
6875 pub command: Vec<String>,
6876 }
6877
6878 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6879 #[serde(rename_all = "camelCase")]
6880 pub struct ArgsItemValueFromFieldRef {
6881 pub field_path: String,
6882 }
6883
6884 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6885 #[serde(rename_all = "camelCase")]
6886 pub struct ContainersItemEnvItemValueFromFieldRef {
6887 pub api_version: String,
6888 pub field_path: String,
6889 }
6890
6891 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6892 #[serde(rename_all = "camelCase")]
6893 pub struct EphemeralContainersItemEnvItemValueFromFieldRef {
6894 pub api_version: String,
6895 pub field_path: String,
6896 }
6897
6898 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6899 #[serde(rename_all = "camelCase")]
6900 pub struct InitContainersItemEnvItemValueFromFieldRef {
6901 pub api_version: String,
6902 pub field_path: String,
6903 }
6904
6905 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6906 #[serde(rename_all = "camelCase")]
6907 pub struct ContainersItemLivenessProbeGrpc {
6908 pub port: i32,
6909 pub service: String,
6910 }
6911
6912 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6913 #[serde(rename_all = "camelCase")]
6914 pub struct ContainersItemReadinessProbeGrpc {
6915 pub port: i32,
6916 pub service: String,
6917 }
6918
6919 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6920 #[serde(rename_all = "camelCase")]
6921 pub struct ContainersItemStartupProbeGrpc {
6922 pub port: i32,
6923 pub service: String,
6924 }
6925
6926 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6927 #[serde(rename_all = "camelCase")]
6928 pub struct EphemeralContainersItemLivenessProbeGrpc {
6929 pub port: i32,
6930 pub service: String,
6931 }
6932
6933 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6934 #[serde(rename_all = "camelCase")]
6935 pub struct EphemeralContainersItemReadinessProbeGrpc {
6936 pub port: i32,
6937 pub service: String,
6938 }
6939
6940 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6941 #[serde(rename_all = "camelCase")]
6942 pub struct EphemeralContainersItemStartupProbeGrpc {
6943 pub port: i32,
6944 pub service: String,
6945 }
6946
6947 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6948 #[serde(rename_all = "camelCase")]
6949 pub struct InitContainersItemLivenessProbeGrpc {
6950 pub port: i32,
6951 pub service: String,
6952 }
6953
6954 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6955 #[serde(rename_all = "camelCase")]
6956 pub struct InitContainersItemReadinessProbeGrpc {
6957 pub port: i32,
6958 pub service: String,
6959 }
6960
6961 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6962 #[serde(rename_all = "camelCase")]
6963 pub struct InitContainersItemStartupProbeGrpc {
6964 pub port: i32,
6965 pub service: String,
6966 }
6967
6968 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6969 #[serde(rename_all = "camelCase")]
6970 pub struct HostAliasesItem {
6971 pub hostnames: Vec<String>,
6972 pub ip: String,
6973 }
6974
6975 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6976 #[serde(rename_all = "camelCase")]
6977 pub struct ContainersItemLifecyclePostStartHttpGet {
6978 pub host: String,
6979 pub http_headers: Vec<ContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
6980 pub path: String,
6981 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6982 pub scheme: String,
6983 }
6984
6985 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6986 #[serde(rename_all = "camelCase")]
6987 pub struct ContainersItemLifecyclePreStopHttpGet {
6988 pub host: String,
6989 pub http_headers: Vec<ContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
6990 pub path: String,
6991 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
6992 pub scheme: String,
6993 }
6994
6995 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
6996 #[serde(rename_all = "camelCase")]
6997 pub struct ContainersItemLivenessProbeHttpGet {
6998 pub host: String,
6999 pub http_headers: Vec<ContainersItemLivenessProbeHttpGetHttpHeadersItem>,
7000 pub path: String,
7001 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7002 pub scheme: String,
7003 }
7004
7005 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7006 #[serde(rename_all = "camelCase")]
7007 pub struct ContainersItemReadinessProbeHttpGet {
7008 pub host: String,
7009 pub http_headers: Vec<ContainersItemReadinessProbeHttpGetHttpHeadersItem>,
7010 pub path: String,
7011 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7012 pub scheme: String,
7013 }
7014
7015 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7016 #[serde(rename_all = "camelCase")]
7017 pub struct ContainersItemStartupProbeHttpGet {
7018 pub host: String,
7019 pub http_headers: Vec<ContainersItemStartupProbeHttpGetHttpHeadersItem>,
7020 pub path: String,
7021 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7022 pub scheme: String,
7023 }
7024
7025 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7026 #[serde(rename_all = "camelCase")]
7027 pub struct EphemeralContainersItemLifecyclePostStartHttpGet {
7028 pub host: String,
7029 pub http_headers:
7030 Vec<EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
7031 pub path: String,
7032 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7033 pub scheme: String,
7034 }
7035
7036 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7037 #[serde(rename_all = "camelCase")]
7038 pub struct EphemeralContainersItemLifecyclePreStopHttpGet {
7039 pub host: String,
7040 pub http_headers:
7041 Vec<EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
7042 pub path: String,
7043 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7044 pub scheme: String,
7045 }
7046
7047 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7048 #[serde(rename_all = "camelCase")]
7049 pub struct EphemeralContainersItemLivenessProbeHttpGet {
7050 pub host: String,
7051 pub http_headers: Vec<EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem>,
7052 pub path: String,
7053 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7054 pub scheme: String,
7055 }
7056
7057 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7058 #[serde(rename_all = "camelCase")]
7059 pub struct EphemeralContainersItemReadinessProbeHttpGet {
7060 pub host: String,
7061 pub http_headers: Vec<EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem>,
7062 pub path: String,
7063 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7064 pub scheme: String,
7065 }
7066
7067 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7068 #[serde(rename_all = "camelCase")]
7069 pub struct EphemeralContainersItemStartupProbeHttpGet {
7070 pub host: String,
7071 pub http_headers: Vec<EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem>,
7072 pub path: String,
7073 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7074 pub scheme: String,
7075 }
7076
7077 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7078 #[serde(rename_all = "camelCase")]
7079 pub struct InitContainersItemLifecyclePostStartHttpGet {
7080 pub host: String,
7081 pub http_headers: Vec<InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
7082 pub path: String,
7083 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7084 pub scheme: String,
7085 }
7086
7087 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7088 #[serde(rename_all = "camelCase")]
7089 pub struct InitContainersItemLifecyclePreStopHttpGet {
7090 pub host: String,
7091 pub http_headers: Vec<InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
7092 pub path: String,
7093 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7094 pub scheme: String,
7095 }
7096
7097 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7098 #[serde(rename_all = "camelCase")]
7099 pub struct InitContainersItemLivenessProbeHttpGet {
7100 pub host: String,
7101 pub http_headers: Vec<InitContainersItemLivenessProbeHttpGetHttpHeadersItem>,
7102 pub path: String,
7103 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7104 pub scheme: String,
7105 }
7106
7107 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7108 #[serde(rename_all = "camelCase")]
7109 pub struct InitContainersItemReadinessProbeHttpGet {
7110 pub host: String,
7111 pub http_headers: Vec<InitContainersItemReadinessProbeHttpGetHttpHeadersItem>,
7112 pub path: String,
7113 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7114 pub scheme: String,
7115 }
7116
7117 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7118 #[serde(rename_all = "camelCase")]
7119 pub struct InitContainersItemStartupProbeHttpGet {
7120 pub host: String,
7121 pub http_headers: Vec<InitContainersItemStartupProbeHttpGetHttpHeadersItem>,
7122 pub path: String,
7123 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7124 pub scheme: String,
7125 }
7126
7127 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7128 #[serde(rename_all = "camelCase")]
7129 pub struct ContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
7130 pub name: String,
7131 pub value: String,
7132 }
7133
7134 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7135 #[serde(rename_all = "camelCase")]
7136 pub struct ContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
7137 pub name: String,
7138 pub value: String,
7139 }
7140
7141 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7142 #[serde(rename_all = "camelCase")]
7143 pub struct ContainersItemLivenessProbeHttpGetHttpHeadersItem {
7144 pub name: String,
7145 pub value: String,
7146 }
7147
7148 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7149 #[serde(rename_all = "camelCase")]
7150 pub struct ContainersItemReadinessProbeHttpGetHttpHeadersItem {
7151 pub name: String,
7152 pub value: String,
7153 }
7154
7155 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7156 #[serde(rename_all = "camelCase")]
7157 pub struct ContainersItemStartupProbeHttpGetHttpHeadersItem {
7158 pub name: String,
7159 pub value: String,
7160 }
7161
7162 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7163 #[serde(rename_all = "camelCase")]
7164 pub struct EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
7165 pub name: String,
7166 pub value: String,
7167 }
7168
7169 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7170 #[serde(rename_all = "camelCase")]
7171 pub struct EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
7172 pub name: String,
7173 pub value: String,
7174 }
7175
7176 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7177 #[serde(rename_all = "camelCase")]
7178 pub struct EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem {
7179 pub name: String,
7180 pub value: String,
7181 }
7182
7183 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7184 #[serde(rename_all = "camelCase")]
7185 pub struct EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem {
7186 pub name: String,
7187 pub value: String,
7188 }
7189
7190 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7191 #[serde(rename_all = "camelCase")]
7192 pub struct EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem {
7193 pub name: String,
7194 pub value: String,
7195 }
7196
7197 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7198 #[serde(rename_all = "camelCase")]
7199 pub struct InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
7200 pub name: String,
7201 pub value: String,
7202 }
7203
7204 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7205 #[serde(rename_all = "camelCase")]
7206 pub struct InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
7207 pub name: String,
7208 pub value: String,
7209 }
7210
7211 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7212 #[serde(rename_all = "camelCase")]
7213 pub struct InitContainersItemLivenessProbeHttpGetHttpHeadersItem {
7214 pub name: String,
7215 pub value: String,
7216 }
7217
7218 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7219 #[serde(rename_all = "camelCase")]
7220 pub struct InitContainersItemReadinessProbeHttpGetHttpHeadersItem {
7221 pub name: String,
7222 pub value: String,
7223 }
7224
7225 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7226 #[serde(rename_all = "camelCase")]
7227 pub struct InitContainersItemStartupProbeHttpGetHttpHeadersItem {
7228 pub name: String,
7229 pub value: String,
7230 }
7231
7232 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7233 #[serde(rename_all = "camelCase")]
7234 pub struct ImagePullSecretsItem {
7235 pub name: String,
7236 }
7237
7238 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7239 #[serde(rename_all = "camelCase")]
7240 pub struct InitContainersItem {
7241 pub args: Vec<String>,
7242 pub command: Vec<String>,
7243 pub env: Vec<InitContainersItemEnvItem>,
7244 pub env_from: Vec<InitContainersItemEnvFromItem>,
7245 pub image: String,
7246 pub image_pull_policy: String,
7247 pub lifecycle: InitContainersItemLifecycle,
7248 pub liveness_probe: InitContainersItemLivenessProbe,
7249 pub name: String,
7250 pub ports: Vec<InitContainersItemPortsItem>,
7251 pub readiness_probe: InitContainersItemReadinessProbe,
7252 pub resources: InitContainersItemResources,
7253 pub security_context: InitContainersItemSecurityContext,
7254 pub startup_probe: InitContainersItemStartupProbe,
7255 pub stdin: bool,
7256 pub stdin_once: bool,
7257 pub termination_message_path: String,
7258 pub termination_message_policy: String,
7259 pub tty: bool,
7260 pub volume_devices: Vec<InitContainersItemVolumeDevicesItem>,
7261 pub volume_mounts: Vec<InitContainersItemVolumeMountsItem>,
7262 pub working_dir: String,
7263 }
7264
7265 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7266 #[serde(rename_all = "camelCase")]
7267 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
7268 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
7269 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
7270 }
7271
7272 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7273 #[serde(rename_all = "camelCase")]
7274 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
7275 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
7276 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
7277 }
7278
7279 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7280 #[serde(rename_all = "camelCase")]
7281 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
7282 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
7283 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
7284 }
7285
7286 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7287 #[serde(rename_all = "camelCase")]
7288 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
7289 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
7290 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
7291 }
7292
7293 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7294 #[serde(rename_all = "camelCase")]
7295 pub struct TopologySpreadConstraintsItemLabelSelector {
7296 pub match_expressions:
7297 Vec<TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem>,
7298 pub match_labels: TopologySpreadConstraintsItemLabelSelectorMatchLabels,
7299 }
7300
7301 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7302 #[serde(rename_all = "camelCase")]
7303 pub struct Labels {
7304 pub properties: std::collections::HashMap<String, String>,
7305 }
7306
7307 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7308 #[serde(rename_all = "camelCase")]
7309 pub struct ContainersItemLifecycle {
7310 pub post_start: ContainersItemLifecyclePostStart,
7311 pub pre_stop: ContainersItemLifecyclePreStop,
7312 }
7313
7314 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7315 #[serde(rename_all = "camelCase")]
7316 pub struct EphemeralContainersItemLifecycle {
7317 pub post_start: EphemeralContainersItemLifecyclePostStart,
7318 pub pre_stop: EphemeralContainersItemLifecyclePreStop,
7319 }
7320
7321 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7322 #[serde(rename_all = "camelCase")]
7323 pub struct InitContainersItemLifecycle {
7324 pub post_start: InitContainersItemLifecyclePostStart,
7325 pub pre_stop: InitContainersItemLifecyclePreStop,
7326 }
7327
7328 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7329 #[serde(rename_all = "camelCase")]
7330 pub struct ContainersItemLivenessProbe {
7331 pub exec: ContainersItemLivenessProbeExec,
7332 pub failure_threshold: i32,
7333 pub grpc: ContainersItemLivenessProbeGrpc,
7334 pub http_get: ContainersItemLivenessProbeHttpGet,
7335 pub initial_delay_seconds: i32,
7336 pub period_seconds: i32,
7337 pub success_threshold: i32,
7338 pub tcp_socket: ContainersItemLivenessProbeTcpSocket,
7339 pub termination_grace_period_seconds: i64,
7340 pub timeout_seconds: i32,
7341 }
7342
7343 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7344 #[serde(rename_all = "camelCase")]
7345 pub struct EphemeralContainersItemLivenessProbe {
7346 pub exec: EphemeralContainersItemLivenessProbeExec,
7347 pub failure_threshold: i32,
7348 pub grpc: EphemeralContainersItemLivenessProbeGrpc,
7349 pub http_get: EphemeralContainersItemLivenessProbeHttpGet,
7350 pub initial_delay_seconds: i32,
7351 pub period_seconds: i32,
7352 pub success_threshold: i32,
7353 pub tcp_socket: EphemeralContainersItemLivenessProbeTcpSocket,
7354 pub termination_grace_period_seconds: i64,
7355 pub timeout_seconds: i32,
7356 }
7357
7358 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7359 #[serde(rename_all = "camelCase")]
7360 pub struct InitContainersItemLivenessProbe {
7361 pub exec: InitContainersItemLivenessProbeExec,
7362 pub failure_threshold: i32,
7363 pub grpc: InitContainersItemLivenessProbeGrpc,
7364 pub http_get: InitContainersItemLivenessProbeHttpGet,
7365 pub initial_delay_seconds: i32,
7366 pub period_seconds: i32,
7367 pub success_threshold: i32,
7368 pub tcp_socket: InitContainersItemLivenessProbeTcpSocket,
7369 pub termination_grace_period_seconds: i64,
7370 pub timeout_seconds: i32,
7371 }
7372
7373 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7374 #[serde(rename_all = "camelCase")]
7375 pub struct SelectorMatchExpressionsItem {
7376 pub key: String,
7377 pub operator: String,
7378 pub values: Vec<String>,
7379 }
7380
7381 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7382 #[serde(rename_all = "camelCase")]
7383 pub struct PreferenceMatchExpressionsItem {
7384 pub key: String,
7385 pub operator: String,
7386 pub values: Vec<String>,
7387 }
7388
7389 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7390 #[serde(rename_all = "camelCase")]
7391 pub struct NodeSelectorTermsItemMatchExpressionsItem {
7392 pub key: String,
7393 pub operator: String,
7394 pub values: Vec<String>,
7395 }
7396
7397 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7398 #[serde(rename_all = "camelCase")]
7399 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
7400 {
7401 pub key: String,
7402 pub operator: String,
7403 pub values: Vec<String>,
7404 }
7405
7406 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7407 #[serde(rename_all = "camelCase")]
7408 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
7409 {
7410 pub key: String,
7411 pub operator: String,
7412 pub values: Vec<String>,
7413 }
7414
7415 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7416 #[serde(rename_all = "camelCase")]
7417 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
7418 {
7419 pub key: String,
7420 pub operator: String,
7421 pub values: Vec<String>,
7422 }
7423
7424 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7425 #[serde(rename_all = "camelCase")]
7426 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
7427 {
7428 pub key: String,
7429 pub operator: String,
7430 pub values: Vec<String>,
7431 }
7432
7433 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7434 #[serde(rename_all = "camelCase")]
7435 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
7436 {
7437 pub key: String,
7438 pub operator: String,
7439 pub values: Vec<String>,
7440 }
7441
7442 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7443 #[serde(rename_all = "camelCase")]
7444 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
7445 {
7446 pub key: String,
7447 pub operator: String,
7448 pub values: Vec<String>,
7449 }
7450
7451 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7452 #[serde(rename_all = "camelCase")]
7453 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
7454 {
7455 pub key: String,
7456 pub operator: String,
7457 pub values: Vec<String>,
7458 }
7459
7460 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7461 #[serde(rename_all = "camelCase")]
7462 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
7463 {
7464 pub key: String,
7465 pub operator: String,
7466 pub values: Vec<String>,
7467 }
7468
7469 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7470 #[serde(rename_all = "camelCase")]
7471 pub struct TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem {
7472 pub key: String,
7473 pub operator: String,
7474 pub values: Vec<String>,
7475 }
7476
7477 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7478 #[serde(rename_all = "camelCase")]
7479 pub struct PreferenceMatchFieldsItem {
7480 pub key: String,
7481 pub operator: String,
7482 pub values: Vec<String>,
7483 }
7484
7485 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7486 #[serde(rename_all = "camelCase")]
7487 pub struct NodeSelectorTermsItemMatchFieldsItem {
7488 pub key: String,
7489 pub operator: String,
7490 pub values: Vec<String>,
7491 }
7492
7493 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7494 #[serde(rename_all = "camelCase")]
7495 pub struct SelectorMatchLabels {
7496 pub properties: std::collections::HashMap<String, String>,
7497 }
7498
7499 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7500 #[serde(rename_all = "camelCase")]
7501 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
7502 {
7503 pub properties: std::collections::HashMap<String, String>,
7504 }
7505
7506 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7507 #[serde(rename_all = "camelCase")]
7508 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
7509 {
7510 pub properties: std::collections::HashMap<String, String>,
7511 }
7512
7513 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7514 #[serde(rename_all = "camelCase")]
7515 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels {
7516 pub properties: std::collections::HashMap<String, String>,
7517 }
7518
7519 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7520 #[serde(rename_all = "camelCase")]
7521 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
7522 {
7523 pub properties: std::collections::HashMap<String, String>,
7524 }
7525
7526 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7527 #[serde(rename_all = "camelCase")]
7528 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
7529 {
7530 pub properties: std::collections::HashMap<String, String>,
7531 }
7532
7533 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7534 #[serde(rename_all = "camelCase")]
7535 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
7536 {
7537 pub properties: std::collections::HashMap<String, String>,
7538 }
7539
7540 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7541 #[serde(rename_all = "camelCase")]
7542 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels
7543 {
7544 pub properties: std::collections::HashMap<String, String>,
7545 }
7546
7547 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7548 #[serde(rename_all = "camelCase")]
7549 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
7550 {
7551 pub properties: std::collections::HashMap<String, String>,
7552 }
7553
7554 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7555 #[serde(rename_all = "camelCase")]
7556 pub struct TopologySpreadConstraintsItemLabelSelectorMatchLabels {
7557 pub properties: std::collections::HashMap<String, String>,
7558 }
7559
7560 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7561 #[serde(rename_all = "camelCase")]
7562 pub struct MeasurementRetentionItem {
7563 pub limit: i32,
7564 pub metric_name: String,
7565 }
7566
7567 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7568 #[serde(rename_all = "camelCase")]
7569 pub struct Metadata {
7570 pub annotations: Annotations,
7571 pub labels: Labels,
7572 }
7573
7574 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7575 #[serde(rename_all = "camelCase")]
7576 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
7577 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
7578 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
7579 }
7580
7581 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7582 #[serde(rename_all = "camelCase")]
7583 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
7584 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
7585 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
7586 }
7587
7588 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7589 #[serde(rename_all = "camelCase")]
7590 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
7591 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
7592 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
7593 }
7594
7595 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7596 #[serde(rename_all = "camelCase")]
7597 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
7598 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
7599 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
7600 }
7601
7602 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7603 #[serde(rename_all = "camelCase")]
7604 pub struct NodeAffinity {
7605 pub preferred_during_scheduling_ignored_during_execution:
7606 Vec<NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
7607 pub required_during_scheduling_ignored_during_execution:
7608 RequiredDuringSchedulingIgnoredDuringExecution,
7609 }
7610
7611 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7612 #[serde(rename_all = "camelCase")]
7613 pub struct NodeSelector {
7614 pub properties: std::collections::HashMap<String, String>,
7615 }
7616
7617 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7618 #[serde(rename_all = "camelCase")]
7619 pub struct NodeSelectorTermsItem {
7620 pub match_expressions: Vec<NodeSelectorTermsItemMatchExpressionsItem>,
7621 pub match_fields: Vec<NodeSelectorTermsItemMatchFieldsItem>,
7622 }
7623
7624 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7625 #[serde(rename_all = "camelCase")]
7626 pub struct OptionsItem {
7627 pub name: String,
7628 pub value: String,
7629 }
7630
7631 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7632 #[serde(rename_all = "camelCase")]
7633 pub struct Os {
7634 pub name: String,
7635 }
7636
7637 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7638 #[serde(rename_all = "camelCase")]
7639 pub struct Overhead {
7640 pub properties: std::collections::HashMap<
7641 String,
7642 k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7643 >,
7644 }
7645
7646 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7647 #[serde(rename_all = "camelCase")]
7648 pub struct PodAffinity {
7649 pub preferred_during_scheduling_ignored_during_execution:
7650 Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
7651 pub required_during_scheduling_ignored_during_execution:
7652 Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
7653 }
7654
7655 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7656 #[serde(rename_all = "camelCase")]
7657 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
7658 pub label_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
7659 pub namespace_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
7660 pub namespaces: Vec<String>,
7661 pub topology_key: String,
7662 }
7663
7664 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7665 #[serde(rename_all = "camelCase")]
7666 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
7667 pub label_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
7668 pub namespace_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
7669 pub namespaces: Vec<String>,
7670 pub topology_key: String,
7671 }
7672
7673 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7674 #[serde(rename_all = "camelCase")]
7675 pub struct PodAntiAffinity {
7676 pub preferred_during_scheduling_ignored_during_execution:
7677 Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
7678 pub required_during_scheduling_ignored_during_execution:
7679 Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
7680 }
7681
7682 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7683 #[serde(rename_all = "camelCase")]
7684 pub struct ContainersItemPortsItem {
7685 pub container_port: i32,
7686 pub host_i_p: String,
7687 pub host_port: i32,
7688 pub name: String,
7689 pub protocol: String,
7690 }
7691
7692 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7693 #[serde(rename_all = "camelCase")]
7694 pub struct EphemeralContainersItemPortsItem {
7695 pub container_port: i32,
7696 pub host_i_p: String,
7697 pub host_port: i32,
7698 pub name: String,
7699 pub protocol: String,
7700 }
7701
7702 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7703 #[serde(rename_all = "camelCase")]
7704 pub struct InitContainersItemPortsItem {
7705 pub container_port: i32,
7706 pub host_i_p: String,
7707 pub host_port: i32,
7708 pub name: String,
7709 pub protocol: String,
7710 }
7711
7712 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7713 #[serde(rename_all = "camelCase")]
7714 pub struct ContainersItemLifecyclePostStart {
7715 pub exec: ContainersItemLifecyclePostStartExec,
7716 pub http_get: ContainersItemLifecyclePostStartHttpGet,
7717 pub tcp_socket: ContainersItemLifecyclePostStartTcpSocket,
7718 }
7719
7720 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7721 #[serde(rename_all = "camelCase")]
7722 pub struct EphemeralContainersItemLifecyclePostStart {
7723 pub exec: EphemeralContainersItemLifecyclePostStartExec,
7724 pub http_get: EphemeralContainersItemLifecyclePostStartHttpGet,
7725 pub tcp_socket: EphemeralContainersItemLifecyclePostStartTcpSocket,
7726 }
7727
7728 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7729 #[serde(rename_all = "camelCase")]
7730 pub struct InitContainersItemLifecyclePostStart {
7731 pub exec: InitContainersItemLifecyclePostStartExec,
7732 pub http_get: InitContainersItemLifecyclePostStartHttpGet,
7733 pub tcp_socket: InitContainersItemLifecyclePostStartTcpSocket,
7734 }
7735
7736 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7737 #[serde(rename_all = "camelCase")]
7738 pub struct ContainersItemLifecyclePreStop {
7739 pub exec: ContainersItemLifecyclePreStopExec,
7740 pub http_get: ContainersItemLifecyclePreStopHttpGet,
7741 pub tcp_socket: ContainersItemLifecyclePreStopTcpSocket,
7742 }
7743
7744 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7745 #[serde(rename_all = "camelCase")]
7746 pub struct EphemeralContainersItemLifecyclePreStop {
7747 pub exec: EphemeralContainersItemLifecyclePreStopExec,
7748 pub http_get: EphemeralContainersItemLifecyclePreStopHttpGet,
7749 pub tcp_socket: EphemeralContainersItemLifecyclePreStopTcpSocket,
7750 }
7751
7752 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7753 #[serde(rename_all = "camelCase")]
7754 pub struct InitContainersItemLifecyclePreStop {
7755 pub exec: InitContainersItemLifecyclePreStopExec,
7756 pub http_get: InitContainersItemLifecyclePreStopHttpGet,
7757 pub tcp_socket: InitContainersItemLifecyclePreStopTcpSocket,
7758 }
7759
7760 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7761 #[serde(rename_all = "camelCase")]
7762 pub struct Preference {
7763 pub match_expressions: Vec<PreferenceMatchExpressionsItem>,
7764 pub match_fields: Vec<PreferenceMatchFieldsItem>,
7765 }
7766
7767 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7768 #[serde(rename_all = "camelCase")]
7769 pub struct NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
7770 pub preference: Preference,
7771 pub weight: i32,
7772 }
7773
7774 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7775 #[serde(rename_all = "camelCase")]
7776 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
7777 pub pod_affinity_term:
7778 PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
7779 pub weight: i32,
7780 }
7781
7782 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7783 #[serde(rename_all = "camelCase")]
7784 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
7785 pub pod_affinity_term: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
7786 pub weight: i32,
7787 }
7788
7789 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7790 #[serde(rename_all = "camelCase")]
7791 pub struct ReadinessGatesItem {
7792 pub condition_type: String,
7793 }
7794
7795 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7796 #[serde(rename_all = "camelCase")]
7797 pub struct ContainersItemReadinessProbe {
7798 pub exec: ContainersItemReadinessProbeExec,
7799 pub failure_threshold: i32,
7800 pub grpc: ContainersItemReadinessProbeGrpc,
7801 pub http_get: ContainersItemReadinessProbeHttpGet,
7802 pub initial_delay_seconds: i32,
7803 pub period_seconds: i32,
7804 pub success_threshold: i32,
7805 pub tcp_socket: ContainersItemReadinessProbeTcpSocket,
7806 pub termination_grace_period_seconds: i64,
7807 pub timeout_seconds: i32,
7808 }
7809
7810 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7811 #[serde(rename_all = "camelCase")]
7812 pub struct EphemeralContainersItemReadinessProbe {
7813 pub exec: EphemeralContainersItemReadinessProbeExec,
7814 pub failure_threshold: i32,
7815 pub grpc: EphemeralContainersItemReadinessProbeGrpc,
7816 pub http_get: EphemeralContainersItemReadinessProbeHttpGet,
7817 pub initial_delay_seconds: i32,
7818 pub period_seconds: i32,
7819 pub success_threshold: i32,
7820 pub tcp_socket: EphemeralContainersItemReadinessProbeTcpSocket,
7821 pub termination_grace_period_seconds: i64,
7822 pub timeout_seconds: i32,
7823 }
7824
7825 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7826 #[serde(rename_all = "camelCase")]
7827 pub struct InitContainersItemReadinessProbe {
7828 pub exec: InitContainersItemReadinessProbeExec,
7829 pub failure_threshold: i32,
7830 pub grpc: InitContainersItemReadinessProbeGrpc,
7831 pub http_get: InitContainersItemReadinessProbeHttpGet,
7832 pub initial_delay_seconds: i32,
7833 pub period_seconds: i32,
7834 pub success_threshold: i32,
7835 pub tcp_socket: InitContainersItemReadinessProbeTcpSocket,
7836 pub termination_grace_period_seconds: i64,
7837 pub timeout_seconds: i32,
7838 }
7839
7840 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7841 #[serde(rename_all = "camelCase")]
7842 pub struct RequiredDuringSchedulingIgnoredDuringExecution {
7843 pub node_selector_terms: Vec<NodeSelectorTermsItem>,
7844 }
7845
7846 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7847 #[serde(rename_all = "camelCase")]
7848 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
7849 pub label_selector:
7850 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
7851 pub namespace_selector:
7852 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
7853 pub namespaces: Vec<String>,
7854 pub topology_key: String,
7855 }
7856
7857 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7858 #[serde(rename_all = "camelCase")]
7859 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
7860 pub label_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
7861 pub namespace_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
7862 pub namespaces: Vec<String>,
7863 pub topology_key: String,
7864 }
7865
7866 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7867 #[serde(rename_all = "camelCase")]
7868 pub struct ContainersItemEnvItemValueFromResourceFieldRef {
7869 pub container_name: String,
7870 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7871 pub resource: String,
7872 }
7873
7874 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7875 #[serde(rename_all = "camelCase")]
7876 pub struct EphemeralContainersItemEnvItemValueFromResourceFieldRef {
7877 pub container_name: String,
7878 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7879 pub resource: String,
7880 }
7881
7882 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7883 #[serde(rename_all = "camelCase")]
7884 pub struct InitContainersItemEnvItemValueFromResourceFieldRef {
7885 pub container_name: String,
7886 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
7887 pub resource: String,
7888 }
7889
7890 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7891 #[serde(rename_all = "camelCase")]
7892 pub struct ContainersItemResources {
7893 pub limits: serde_json::Map<String, serde_json::Value>,
7894 pub requests: serde_json::Map<String, serde_json::Value>,
7895 }
7896
7897 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7898 #[serde(rename_all = "camelCase")]
7899 pub struct EphemeralContainersItemResources {
7900 pub limits: serde_json::Map<String, serde_json::Value>,
7901 pub requests: serde_json::Map<String, serde_json::Value>,
7902 }
7903
7904 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7905 #[serde(rename_all = "camelCase")]
7906 pub struct InitContainersItemResources {
7907 pub limits: serde_json::Map<String, serde_json::Value>,
7908 pub requests: serde_json::Map<String, serde_json::Value>,
7909 }
7910
7911 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7912 #[serde(rename_all = "camelCase")]
7913 pub struct ContainersItemSecurityContextSeLinuxOptions {
7914 pub level: String,
7915 pub role: String,
7916 pub r#type: String,
7917 pub user: String,
7918 }
7919
7920 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7921 #[serde(rename_all = "camelCase")]
7922 pub struct EphemeralContainersItemSecurityContextSeLinuxOptions {
7923 pub level: String,
7924 pub role: String,
7925 pub r#type: String,
7926 pub user: String,
7927 }
7928
7929 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7930 #[serde(rename_all = "camelCase")]
7931 pub struct InitContainersItemSecurityContextSeLinuxOptions {
7932 pub level: String,
7933 pub role: String,
7934 pub r#type: String,
7935 pub user: String,
7936 }
7937
7938 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7939 #[serde(rename_all = "camelCase")]
7940 pub struct SpecSecurityContextSeLinuxOptions {
7941 pub level: String,
7942 pub role: String,
7943 pub r#type: String,
7944 pub user: String,
7945 }
7946
7947 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7948 #[serde(rename_all = "camelCase")]
7949 pub struct ContainersItemSecurityContextSeccompProfile {
7950 pub localhost_profile: String,
7951 pub r#type: String,
7952 }
7953
7954 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7955 #[serde(rename_all = "camelCase")]
7956 pub struct EphemeralContainersItemSecurityContextSeccompProfile {
7957 pub localhost_profile: String,
7958 pub r#type: String,
7959 }
7960
7961 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7962 #[serde(rename_all = "camelCase")]
7963 pub struct InitContainersItemSecurityContextSeccompProfile {
7964 pub localhost_profile: String,
7965 pub r#type: String,
7966 }
7967
7968 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7969 #[serde(rename_all = "camelCase")]
7970 pub struct SpecSecurityContextSeccompProfile {
7971 pub localhost_profile: String,
7972 pub r#type: String,
7973 }
7974
7975 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7976 #[serde(rename_all = "camelCase")]
7977 pub struct ArgsItemValueFromSecretKeyRef {
7978 pub key: String,
7979 pub name: String,
7980 }
7981
7982 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7983 #[serde(rename_all = "camelCase")]
7984 pub struct ContainersItemEnvItemValueFromSecretKeyRef {
7985 pub key: String,
7986 pub name: String,
7987 pub optional: bool,
7988 }
7989
7990 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7991 #[serde(rename_all = "camelCase")]
7992 pub struct EphemeralContainersItemEnvItemValueFromSecretKeyRef {
7993 pub key: String,
7994 pub name: String,
7995 pub optional: bool,
7996 }
7997
7998 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
7999 #[serde(rename_all = "camelCase")]
8000 pub struct InitContainersItemEnvItemValueFromSecretKeyRef {
8001 pub key: String,
8002 pub name: String,
8003 pub optional: bool,
8004 }
8005
8006 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8007 #[serde(rename_all = "camelCase")]
8008 pub struct ContainersItemEnvFromItemSecretRef {
8009 pub name: String,
8010 pub optional: bool,
8011 }
8012
8013 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8014 #[serde(rename_all = "camelCase")]
8015 pub struct EphemeralContainersItemEnvFromItemSecretRef {
8016 pub name: String,
8017 pub optional: bool,
8018 }
8019
8020 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8021 #[serde(rename_all = "camelCase")]
8022 pub struct InitContainersItemEnvFromItemSecretRef {
8023 pub name: String,
8024 pub optional: bool,
8025 }
8026
8027 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8028 #[serde(rename_all = "camelCase")]
8029 pub struct SpecSecurityContext {
8030 pub fs_group: i64,
8031 pub fs_group_change_policy: String,
8032 pub run_as_group: i64,
8033 pub run_as_non_root: bool,
8034 pub run_as_user: i64,
8035 pub se_linux_options: SpecSecurityContextSeLinuxOptions,
8036 pub seccomp_profile: SpecSecurityContextSeccompProfile,
8037 pub supplemental_groups: Vec<i64>,
8038 pub sysctls: Vec<SysctlsItem>,
8039 pub windows_options: SpecSecurityContextWindowsOptions,
8040 }
8041
8042 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8043 #[serde(rename_all = "camelCase")]
8044 pub struct ContainersItemSecurityContext {
8045 pub allow_privilege_escalation: bool,
8046 pub capabilities: ContainersItemSecurityContextCapabilities,
8047 pub privileged: bool,
8048 pub proc_mount: String,
8049 pub read_only_root_filesystem: bool,
8050 pub run_as_group: i64,
8051 pub run_as_non_root: bool,
8052 pub run_as_user: i64,
8053 pub se_linux_options: ContainersItemSecurityContextSeLinuxOptions,
8054 pub seccomp_profile: ContainersItemSecurityContextSeccompProfile,
8055 pub windows_options: ContainersItemSecurityContextWindowsOptions,
8056 }
8057
8058 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8059 #[serde(rename_all = "camelCase")]
8060 pub struct EphemeralContainersItemSecurityContext {
8061 pub allow_privilege_escalation: bool,
8062 pub capabilities: EphemeralContainersItemSecurityContextCapabilities,
8063 pub privileged: bool,
8064 pub proc_mount: String,
8065 pub read_only_root_filesystem: bool,
8066 pub run_as_group: i64,
8067 pub run_as_non_root: bool,
8068 pub run_as_user: i64,
8069 pub se_linux_options: EphemeralContainersItemSecurityContextSeLinuxOptions,
8070 pub seccomp_profile: EphemeralContainersItemSecurityContextSeccompProfile,
8071 pub windows_options: EphemeralContainersItemSecurityContextWindowsOptions,
8072 }
8073
8074 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8075 #[serde(rename_all = "camelCase")]
8076 pub struct InitContainersItemSecurityContext {
8077 pub allow_privilege_escalation: bool,
8078 pub capabilities: InitContainersItemSecurityContextCapabilities,
8079 pub privileged: bool,
8080 pub proc_mount: String,
8081 pub read_only_root_filesystem: bool,
8082 pub run_as_group: i64,
8083 pub run_as_non_root: bool,
8084 pub run_as_user: i64,
8085 pub se_linux_options: InitContainersItemSecurityContextSeLinuxOptions,
8086 pub seccomp_profile: InitContainersItemSecurityContextSeccompProfile,
8087 pub windows_options: InitContainersItemSecurityContextWindowsOptions,
8088 }
8089
8090 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8091 #[serde(rename_all = "camelCase")]
8092 pub struct Selector {
8093 pub match_expressions: Vec<SelectorMatchExpressionsItem>,
8094 pub match_labels: SelectorMatchLabels,
8095 }
8096
8097 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8098 #[serde(rename_all = "camelCase")]
8099 pub struct Service {
8100 pub properties: serde_json::Map<String, serde_json::Value>,
8101 }
8102
8103 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8104 #[serde(rename_all = "camelCase")]
8105 pub struct Spec {
8106 pub analyses: Vec<AnalysesItem>,
8107 pub dry_run: Vec<DryRunItem>,
8108 pub duration: String,
8109 pub measurement_retention: Vec<MeasurementRetentionItem>,
8110 pub progress_deadline_seconds: i32,
8111 pub scale_down_delay_seconds: i32,
8112 pub templates: Vec<TemplatesItem>,
8113 pub terminate: bool,
8114 }
8115
8116 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8117 #[serde(rename_all = "camelCase")]
8118 pub struct TemplateSpec {
8119 pub active_deadline_seconds: i64,
8120 pub affinity: Affinity,
8121 pub automount_service_account_token: bool,
8122 pub containers: Vec<ContainersItem>,
8123 pub dns_config: DnsConfig,
8124 pub dns_policy: String,
8125 pub enable_service_links: bool,
8126 pub ephemeral_containers: Vec<EphemeralContainersItem>,
8127 pub host_aliases: Vec<HostAliasesItem>,
8128 pub host_i_p_c: bool,
8129 pub host_network: bool,
8130 pub host_p_i_d: bool,
8131 pub hostname: String,
8132 pub image_pull_secrets: Vec<ImagePullSecretsItem>,
8133 pub init_containers: Vec<InitContainersItem>,
8134 pub node_name: String,
8135 pub node_selector: NodeSelector,
8136 pub os: Os,
8137 pub overhead: Overhead,
8138 pub preemption_policy: String,
8139 pub priority: i32,
8140 pub priority_class_name: String,
8141 pub readiness_gates: Vec<ReadinessGatesItem>,
8142 pub restart_policy: String,
8143 pub runtime_class_name: String,
8144 pub scheduler_name: String,
8145 pub security_context: SpecSecurityContext,
8146 pub service_account: String,
8147 pub service_account_name: String,
8148 pub set_hostname_as_f_q_d_n: bool,
8149 pub share_process_namespace: bool,
8150 pub subdomain: String,
8151 pub termination_grace_period_seconds: i64,
8152 pub tolerations: Vec<TolerationsItem>,
8153 pub topology_spread_constraints: Vec<TopologySpreadConstraintsItem>,
8154 pub volumes: serde_json::Map<String, serde_json::Value>,
8155 }
8156
8157 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8158 #[serde(rename_all = "camelCase")]
8159 pub struct ContainersItemStartupProbe {
8160 pub exec: ContainersItemStartupProbeExec,
8161 pub failure_threshold: i32,
8162 pub grpc: ContainersItemStartupProbeGrpc,
8163 pub http_get: ContainersItemStartupProbeHttpGet,
8164 pub initial_delay_seconds: i32,
8165 pub period_seconds: i32,
8166 pub success_threshold: i32,
8167 pub tcp_socket: ContainersItemStartupProbeTcpSocket,
8168 pub termination_grace_period_seconds: i64,
8169 pub timeout_seconds: i32,
8170 }
8171
8172 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8173 #[serde(rename_all = "camelCase")]
8174 pub struct EphemeralContainersItemStartupProbe {
8175 pub exec: EphemeralContainersItemStartupProbeExec,
8176 pub failure_threshold: i32,
8177 pub grpc: EphemeralContainersItemStartupProbeGrpc,
8178 pub http_get: EphemeralContainersItemStartupProbeHttpGet,
8179 pub initial_delay_seconds: i32,
8180 pub period_seconds: i32,
8181 pub success_threshold: i32,
8182 pub tcp_socket: EphemeralContainersItemStartupProbeTcpSocket,
8183 pub termination_grace_period_seconds: i64,
8184 pub timeout_seconds: i32,
8185 }
8186
8187 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8188 #[serde(rename_all = "camelCase")]
8189 pub struct InitContainersItemStartupProbe {
8190 pub exec: InitContainersItemStartupProbeExec,
8191 pub failure_threshold: i32,
8192 pub grpc: InitContainersItemStartupProbeGrpc,
8193 pub http_get: InitContainersItemStartupProbeHttpGet,
8194 pub initial_delay_seconds: i32,
8195 pub period_seconds: i32,
8196 pub success_threshold: i32,
8197 pub tcp_socket: InitContainersItemStartupProbeTcpSocket,
8198 pub termination_grace_period_seconds: i64,
8199 pub timeout_seconds: i32,
8200 }
8201
8202 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8203 #[serde(rename_all = "camelCase")]
8204 pub struct Status {
8205 pub analysis_runs: Vec<AnalysisRunsItem>,
8206 pub available_at: String,
8207 pub conditions: Vec<ConditionsItem>,
8208 pub message: String,
8209 pub phase: String,
8210 pub template_statuses: Vec<TemplateStatusesItem>,
8211 }
8212
8213 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8214 #[serde(rename_all = "camelCase")]
8215 pub struct SysctlsItem {
8216 pub name: String,
8217 pub value: String,
8218 }
8219
8220 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8221 #[serde(rename_all = "camelCase")]
8222 pub struct ContainersItemLifecyclePostStartTcpSocket {
8223 pub host: String,
8224 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8225 }
8226
8227 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8228 #[serde(rename_all = "camelCase")]
8229 pub struct ContainersItemLifecyclePreStopTcpSocket {
8230 pub host: String,
8231 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8232 }
8233
8234 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8235 #[serde(rename_all = "camelCase")]
8236 pub struct ContainersItemLivenessProbeTcpSocket {
8237 pub host: String,
8238 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8239 }
8240
8241 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8242 #[serde(rename_all = "camelCase")]
8243 pub struct ContainersItemReadinessProbeTcpSocket {
8244 pub host: String,
8245 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8246 }
8247
8248 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8249 #[serde(rename_all = "camelCase")]
8250 pub struct ContainersItemStartupProbeTcpSocket {
8251 pub host: String,
8252 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8253 }
8254
8255 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8256 #[serde(rename_all = "camelCase")]
8257 pub struct EphemeralContainersItemLifecyclePostStartTcpSocket {
8258 pub host: String,
8259 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8260 }
8261
8262 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8263 #[serde(rename_all = "camelCase")]
8264 pub struct EphemeralContainersItemLifecyclePreStopTcpSocket {
8265 pub host: String,
8266 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8267 }
8268
8269 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8270 #[serde(rename_all = "camelCase")]
8271 pub struct EphemeralContainersItemLivenessProbeTcpSocket {
8272 pub host: String,
8273 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8274 }
8275
8276 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8277 #[serde(rename_all = "camelCase")]
8278 pub struct EphemeralContainersItemReadinessProbeTcpSocket {
8279 pub host: String,
8280 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8281 }
8282
8283 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8284 #[serde(rename_all = "camelCase")]
8285 pub struct EphemeralContainersItemStartupProbeTcpSocket {
8286 pub host: String,
8287 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8288 }
8289
8290 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8291 #[serde(rename_all = "camelCase")]
8292 pub struct InitContainersItemLifecyclePostStartTcpSocket {
8293 pub host: String,
8294 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8295 }
8296
8297 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8298 #[serde(rename_all = "camelCase")]
8299 pub struct InitContainersItemLifecyclePreStopTcpSocket {
8300 pub host: String,
8301 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8302 }
8303
8304 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8305 #[serde(rename_all = "camelCase")]
8306 pub struct InitContainersItemLivenessProbeTcpSocket {
8307 pub host: String,
8308 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8309 }
8310
8311 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8312 #[serde(rename_all = "camelCase")]
8313 pub struct InitContainersItemReadinessProbeTcpSocket {
8314 pub host: String,
8315 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8316 }
8317
8318 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8319 #[serde(rename_all = "camelCase")]
8320 pub struct InitContainersItemStartupProbeTcpSocket {
8321 pub host: String,
8322 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8323 }
8324
8325 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8326 #[serde(rename_all = "camelCase")]
8327 pub struct Template {
8328 pub metadata: Metadata,
8329 pub spec: TemplateSpec,
8330 }
8331
8332 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8333 #[serde(rename_all = "camelCase")]
8334 pub struct TemplateStatusesItem {
8335 pub available_replicas: i32,
8336 pub collision_count: i32,
8337 pub last_transition_time: String,
8338 pub message: String,
8339 pub name: String,
8340 pub pod_template_hash: String,
8341 pub ready_replicas: i32,
8342 pub replicas: i32,
8343 pub service_name: String,
8344 pub status: String,
8345 pub updated_replicas: i32,
8346 }
8347
8348 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8349 #[serde(rename_all = "camelCase")]
8350 pub struct TemplatesItem {
8351 pub min_ready_seconds: i32,
8352 pub name: String,
8353 pub replicas: i32,
8354 pub selector: Selector,
8355 pub service: Service,
8356 pub template: Template,
8357 }
8358
8359 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8360 #[serde(rename_all = "camelCase")]
8361 pub struct TolerationsItem {
8362 pub effect: String,
8363 pub key: String,
8364 pub operator: String,
8365 pub toleration_seconds: i64,
8366 pub value: String,
8367 }
8368
8369 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8370 #[serde(rename_all = "camelCase")]
8371 pub struct TopologySpreadConstraintsItem {
8372 pub label_selector: TopologySpreadConstraintsItemLabelSelector,
8373 pub max_skew: i32,
8374 pub topology_key: String,
8375 pub when_unsatisfiable: String,
8376 }
8377
8378 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8379 #[serde(rename_all = "camelCase")]
8380 pub struct ArgsItemValueFrom {
8381 pub field_ref: ArgsItemValueFromFieldRef,
8382 pub secret_key_ref: ArgsItemValueFromSecretKeyRef,
8383 }
8384
8385 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8386 #[serde(rename_all = "camelCase")]
8387 pub struct ContainersItemEnvItemValueFrom {
8388 pub config_map_key_ref: ContainersItemEnvItemValueFromConfigMapKeyRef,
8389 pub field_ref: ContainersItemEnvItemValueFromFieldRef,
8390 pub resource_field_ref: ContainersItemEnvItemValueFromResourceFieldRef,
8391 pub secret_key_ref: ContainersItemEnvItemValueFromSecretKeyRef,
8392 }
8393
8394 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8395 #[serde(rename_all = "camelCase")]
8396 pub struct EphemeralContainersItemEnvItemValueFrom {
8397 pub config_map_key_ref: EphemeralContainersItemEnvItemValueFromConfigMapKeyRef,
8398 pub field_ref: EphemeralContainersItemEnvItemValueFromFieldRef,
8399 pub resource_field_ref: EphemeralContainersItemEnvItemValueFromResourceFieldRef,
8400 pub secret_key_ref: EphemeralContainersItemEnvItemValueFromSecretKeyRef,
8401 }
8402
8403 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8404 #[serde(rename_all = "camelCase")]
8405 pub struct InitContainersItemEnvItemValueFrom {
8406 pub config_map_key_ref: InitContainersItemEnvItemValueFromConfigMapKeyRef,
8407 pub field_ref: InitContainersItemEnvItemValueFromFieldRef,
8408 pub resource_field_ref: InitContainersItemEnvItemValueFromResourceFieldRef,
8409 pub secret_key_ref: InitContainersItemEnvItemValueFromSecretKeyRef,
8410 }
8411
8412 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8413 #[serde(rename_all = "camelCase")]
8414 pub struct ContainersItemVolumeDevicesItem {
8415 pub device_path: String,
8416 pub name: String,
8417 }
8418
8419 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8420 #[serde(rename_all = "camelCase")]
8421 pub struct EphemeralContainersItemVolumeDevicesItem {
8422 pub device_path: String,
8423 pub name: String,
8424 }
8425
8426 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8427 #[serde(rename_all = "camelCase")]
8428 pub struct InitContainersItemVolumeDevicesItem {
8429 pub device_path: String,
8430 pub name: String,
8431 }
8432
8433 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8434 #[serde(rename_all = "camelCase")]
8435 pub struct ContainersItemVolumeMountsItem {
8436 pub mount_path: String,
8437 pub mount_propagation: String,
8438 pub name: String,
8439 pub read_only: bool,
8440 pub sub_path: String,
8441 pub sub_path_expr: String,
8442 }
8443
8444 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8445 #[serde(rename_all = "camelCase")]
8446 pub struct EphemeralContainersItemVolumeMountsItem {
8447 pub mount_path: String,
8448 pub mount_propagation: String,
8449 pub name: String,
8450 pub read_only: bool,
8451 pub sub_path: String,
8452 pub sub_path_expr: String,
8453 }
8454
8455 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8456 #[serde(rename_all = "camelCase")]
8457 pub struct InitContainersItemVolumeMountsItem {
8458 pub mount_path: String,
8459 pub mount_propagation: String,
8460 pub name: String,
8461 pub read_only: bool,
8462 pub sub_path: String,
8463 pub sub_path_expr: String,
8464 }
8465
8466 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8467 #[serde(rename_all = "camelCase")]
8468 pub struct ContainersItemSecurityContextWindowsOptions {
8469 pub gmsa_credential_spec: String,
8470 pub gmsa_credential_spec_name: String,
8471 pub host_process: bool,
8472 pub run_as_user_name: String,
8473 }
8474
8475 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8476 #[serde(rename_all = "camelCase")]
8477 pub struct EphemeralContainersItemSecurityContextWindowsOptions {
8478 pub gmsa_credential_spec: String,
8479 pub gmsa_credential_spec_name: String,
8480 pub host_process: bool,
8481 pub run_as_user_name: String,
8482 }
8483
8484 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8485 #[serde(rename_all = "camelCase")]
8486 pub struct InitContainersItemSecurityContextWindowsOptions {
8487 pub gmsa_credential_spec: String,
8488 pub gmsa_credential_spec_name: String,
8489 pub host_process: bool,
8490 pub run_as_user_name: String,
8491 }
8492
8493 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8494 #[serde(rename_all = "camelCase")]
8495 pub struct SpecSecurityContextWindowsOptions {
8496 pub gmsa_credential_spec: String,
8497 pub gmsa_credential_spec_name: String,
8498 pub host_process: bool,
8499 pub run_as_user_name: String,
8500 }
8501 }
8502 pub mod rollout {
8503 #[derive(serde::Deserialize, Debug, PartialEq)]
8504 pub struct Rollout {
8505 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
8506 pub spec: Spec,
8507 pub status: Status,
8508 }
8509
8510 impl k8s_openapi::Resource for Rollout {
8511 type Scope = k8s_openapi::ClusterResourceScope;
8512
8513 const API_VERSION: &'static str = "argoproj.io/v1alpha1";
8514 const GROUP: &'static str = "argoproj.io";
8515 const KIND: &'static str = "Rollout";
8516 const VERSION: &'static str = "v1alpha1";
8517 const URL_PATH_SEGMENT: &'static str = "TODO";
8518 }
8519
8520 impl k8s_openapi::Metadata for Rollout {
8521 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
8522
8523 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
8524 &self.metadata
8525 }
8526
8527 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
8528 &mut self.metadata
8529 }
8530 }
8531
8532 impl serde::Serialize for Rollout {
8533 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
8534 where
8535 S: serde::Serializer,
8536 {
8537 use serde::ser::SerializeStruct;
8538 let mut state = serializer.serialize_struct("Rollout", 5)?;
8539 state.serialize_field(
8540 "apiVersion",
8541 <Self as k8s_openapi::Resource>::API_VERSION,
8542 )?;
8543 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
8544 state.serialize_field("metadata", &self.metadata)?;
8545 state.serialize_field("spec", &self.spec)?;
8546 state.serialize_field("status", &self.status)?;
8547 state.end()
8548 }
8549 }
8550
8551 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8552 #[serde(rename_all = "camelCase")]
8553 pub struct ActiveMetadata {
8554 pub annotations: ActiveMetadataAnnotations,
8555 pub labels: ActiveMetadataLabels,
8556 }
8557
8558 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8559 #[serde(rename_all = "camelCase")]
8560 pub struct AdditionalIngressAnnotations {
8561 pub properties: std::collections::HashMap<String, String>,
8562 }
8563
8564 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8565 #[serde(rename_all = "camelCase")]
8566 pub struct AdditionalItem {
8567 pub pod_template_hash: String,
8568 pub service_name: String,
8569 pub weight: i32,
8570 }
8571
8572 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8573 #[serde(rename_all = "camelCase")]
8574 pub struct Affinity {
8575 pub node_affinity: NodeAffinity,
8576 pub pod_affinity: PodAffinity,
8577 pub pod_anti_affinity: PodAntiAffinity,
8578 }
8579
8580 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8581 #[serde(rename_all = "camelCase")]
8582 pub struct TrafficRoutingAlb {
8583 pub annotation_prefix: String,
8584 pub ingress: String,
8585 pub root_service: String,
8586 pub service_port: i32,
8587 pub stickiness_config: StickinessConfig,
8588 }
8589
8590 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8591 #[serde(rename_all = "camelCase")]
8592 pub struct StatusAlb {
8593 pub canary_target_group: CanaryTargetGroup,
8594 pub load_balancer: LoadBalancer,
8595 pub stable_target_group: StableTargetGroup,
8596 }
8597
8598 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8599 #[serde(rename_all = "camelCase")]
8600 pub struct Ambassador {
8601 pub mappings: Vec<String>,
8602 }
8603
8604 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8605 #[serde(rename_all = "camelCase")]
8606 pub struct AnalysesItem {
8607 pub args: Vec<AnalysesItemArgsItem>,
8608 pub cluster_scope: bool,
8609 pub name: String,
8610 pub required_for_completion: bool,
8611 pub template_name: String,
8612 }
8613
8614 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8615 #[serde(rename_all = "camelCase")]
8616 pub struct SpecAnalysis {
8617 pub successful_run_history_limit: i32,
8618 pub unsuccessful_run_history_limit: i32,
8619 }
8620
8621 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8622 #[serde(rename_all = "camelCase")]
8623 pub struct CanaryAnalysis {
8624 pub args: Vec<CanaryAnalysisArgsItem>,
8625 pub dry_run: Vec<CanaryAnalysisDryRunItem>,
8626 pub measurement_retention: Vec<CanaryAnalysisMeasurementRetentionItem>,
8627 pub starting_step: i32,
8628 pub templates: Vec<CanaryAnalysisTemplatesItem>,
8629 }
8630
8631 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8632 #[serde(rename_all = "camelCase")]
8633 pub struct StepsItemAnalysis {
8634 pub args: Vec<StepsItemAnalysisArgsItem>,
8635 pub dry_run: Vec<StepsItemAnalysisDryRunItem>,
8636 pub measurement_retention: Vec<StepsItemAnalysisMeasurementRetentionItem>,
8637 pub templates: Vec<StepsItemAnalysisTemplatesItem>,
8638 }
8639
8640 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8641 #[serde(rename_all = "camelCase")]
8642 pub struct ActiveMetadataAnnotations {
8643 pub properties: std::collections::HashMap<String, String>,
8644 }
8645
8646 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8647 #[serde(rename_all = "camelCase")]
8648 pub struct PreviewMetadataAnnotations {
8649 pub properties: std::collections::HashMap<String, String>,
8650 }
8651
8652 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8653 #[serde(rename_all = "camelCase")]
8654 pub struct CanaryMetadataAnnotations {
8655 pub properties: std::collections::HashMap<String, String>,
8656 }
8657
8658 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8659 #[serde(rename_all = "camelCase")]
8660 pub struct StableMetadataAnnotations {
8661 pub properties: std::collections::HashMap<String, String>,
8662 }
8663
8664 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8665 #[serde(rename_all = "camelCase")]
8666 pub struct TemplatesItemMetadataAnnotations {
8667 pub properties: std::collections::HashMap<String, String>,
8668 }
8669
8670 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8671 #[serde(rename_all = "camelCase")]
8672 pub struct TemplateMetadataAnnotations {
8673 pub properties: std::collections::HashMap<String, String>,
8674 }
8675
8676 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8677 #[serde(rename_all = "camelCase")]
8678 pub struct BlueGreenAntiAffinity {
8679 pub preferred_during_scheduling_ignored_during_execution:
8680 BlueGreenAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution,
8681 pub required_during_scheduling_ignored_during_execution:
8682 BlueGreenAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution,
8683 }
8684
8685 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8686 #[serde(rename_all = "camelCase")]
8687 pub struct CanaryAntiAffinity {
8688 pub preferred_during_scheduling_ignored_during_execution:
8689 CanaryAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution,
8690 pub required_during_scheduling_ignored_during_execution:
8691 CanaryAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution,
8692 }
8693
8694 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8695 #[serde(rename_all = "camelCase")]
8696 pub struct AppMesh {
8697 pub virtual_node_group: VirtualNodeGroup,
8698 pub virtual_service: AppMeshVirtualService,
8699 }
8700
8701 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8702 #[serde(rename_all = "camelCase")]
8703 pub struct PostPromotionAnalysisArgsItem {
8704 pub name: String,
8705 pub value: String,
8706 pub value_from: PostPromotionAnalysisArgsItemValueFrom,
8707 }
8708
8709 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8710 #[serde(rename_all = "camelCase")]
8711 pub struct PrePromotionAnalysisArgsItem {
8712 pub name: String,
8713 pub value: String,
8714 pub value_from: PrePromotionAnalysisArgsItemValueFrom,
8715 }
8716
8717 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8718 #[serde(rename_all = "camelCase")]
8719 pub struct CanaryAnalysisArgsItem {
8720 pub name: String,
8721 pub value: String,
8722 pub value_from: CanaryAnalysisArgsItemValueFrom,
8723 }
8724
8725 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8726 #[serde(rename_all = "camelCase")]
8727 pub struct StepsItemAnalysisArgsItem {
8728 pub name: String,
8729 pub value: String,
8730 pub value_from: StepsItemAnalysisArgsItemValueFrom,
8731 }
8732
8733 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8734 #[serde(rename_all = "camelCase")]
8735 pub struct AnalysesItemArgsItem {
8736 pub name: String,
8737 pub value: String,
8738 pub value_from: AnalysesItemArgsItemValueFrom,
8739 }
8740
8741 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8742 #[serde(rename_all = "camelCase")]
8743 pub struct StrategyBlueGreen {
8744 pub abort_scale_down_delay_seconds: i32,
8745 pub active_metadata: ActiveMetadata,
8746 pub active_service: String,
8747 pub anti_affinity: BlueGreenAntiAffinity,
8748 pub auto_promotion_enabled: bool,
8749 pub auto_promotion_seconds: i32,
8750 pub max_unavailable: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8751 pub post_promotion_analysis: PostPromotionAnalysis,
8752 pub pre_promotion_analysis: PrePromotionAnalysis,
8753 pub preview_metadata: PreviewMetadata,
8754 pub preview_replica_count: i32,
8755 pub preview_service: String,
8756 pub scale_down_delay_revision_limit: i32,
8757 pub scale_down_delay_seconds: i32,
8758 }
8759
8760 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8761 #[serde(rename_all = "camelCase")]
8762 pub struct StatusBlueGreen {
8763 pub active_selector: String,
8764 pub post_promotion_analysis_run_status: PostPromotionAnalysisRunStatus,
8765 pub pre_promotion_analysis_run_status: PrePromotionAnalysisRunStatus,
8766 pub preview_selector: String,
8767 pub scale_up_preview_check_point: bool,
8768 }
8769
8770 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8771 #[serde(rename_all = "camelCase")]
8772 pub struct StrategyCanary {
8773 pub abort_scale_down_delay_seconds: i32,
8774 pub analysis: CanaryAnalysis,
8775 pub anti_affinity: CanaryAntiAffinity,
8776 pub canary_metadata: CanaryMetadata,
8777 pub canary_service: String,
8778 pub dynamic_stable_scale: bool,
8779 pub max_surge: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8780 pub max_unavailable: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
8781 pub ping_pong: PingPong,
8782 pub scale_down_delay_revision_limit: i32,
8783 pub scale_down_delay_seconds: i32,
8784 pub stable_metadata: StableMetadata,
8785 pub stable_service: String,
8786 pub steps: Vec<StepsItem>,
8787 pub traffic_routing: TrafficRouting,
8788 }
8789
8790 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8791 #[serde(rename_all = "camelCase")]
8792 pub struct StatusCanary {
8793 pub current_background_analysis_run_status: CurrentBackgroundAnalysisRunStatus,
8794 pub current_experiment: String,
8795 pub current_step_analysis_run_status: CurrentStepAnalysisRunStatus,
8796 pub stable_ping_pong: String,
8797 pub weights: Weights,
8798 }
8799
8800 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8801 #[serde(rename_all = "camelCase")]
8802 pub struct WeightsCanary {
8803 pub pod_template_hash: String,
8804 pub service_name: String,
8805 pub weight: i32,
8806 }
8807
8808 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8809 #[serde(rename_all = "camelCase")]
8810 pub struct CanaryMetadata {
8811 pub annotations: CanaryMetadataAnnotations,
8812 pub labels: CanaryMetadataLabels,
8813 }
8814
8815 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8816 #[serde(rename_all = "camelCase")]
8817 pub struct CanaryTargetGroup {
8818 pub arn: String,
8819 pub name: String,
8820 }
8821
8822 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8823 #[serde(rename_all = "camelCase")]
8824 pub struct CanaryVirtualNodeRef {
8825 pub name: String,
8826 }
8827
8828 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8829 #[serde(rename_all = "camelCase")]
8830 pub struct ContainersItemSecurityContextCapabilities {
8831 pub add: Vec<String>,
8832 pub drop: Vec<String>,
8833 }
8834
8835 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8836 #[serde(rename_all = "camelCase")]
8837 pub struct EphemeralContainersItemSecurityContextCapabilities {
8838 pub add: Vec<String>,
8839 pub drop: Vec<String>,
8840 }
8841
8842 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8843 #[serde(rename_all = "camelCase")]
8844 pub struct InitContainersItemSecurityContextCapabilities {
8845 pub add: Vec<String>,
8846 pub drop: Vec<String>,
8847 }
8848
8849 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8850 #[serde(rename_all = "camelCase")]
8851 pub struct ConditionsItem {
8852 pub last_transition_time: String,
8853 pub last_update_time: String,
8854 pub message: String,
8855 pub reason: String,
8856 pub status: String,
8857 pub r#type: String,
8858 }
8859
8860 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8861 #[serde(rename_all = "camelCase")]
8862 pub struct ContainersItemEnvItemValueFromConfigMapKeyRef {
8863 pub key: String,
8864 pub name: String,
8865 pub optional: bool,
8866 }
8867
8868 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8869 #[serde(rename_all = "camelCase")]
8870 pub struct EphemeralContainersItemEnvItemValueFromConfigMapKeyRef {
8871 pub key: String,
8872 pub name: String,
8873 pub optional: bool,
8874 }
8875
8876 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8877 #[serde(rename_all = "camelCase")]
8878 pub struct InitContainersItemEnvItemValueFromConfigMapKeyRef {
8879 pub key: String,
8880 pub name: String,
8881 pub optional: bool,
8882 }
8883
8884 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8885 #[serde(rename_all = "camelCase")]
8886 pub struct ContainersItemEnvFromItemConfigMapRef {
8887 pub name: String,
8888 pub optional: bool,
8889 }
8890
8891 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8892 #[serde(rename_all = "camelCase")]
8893 pub struct EphemeralContainersItemEnvFromItemConfigMapRef {
8894 pub name: String,
8895 pub optional: bool,
8896 }
8897
8898 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8899 #[serde(rename_all = "camelCase")]
8900 pub struct InitContainersItemEnvFromItemConfigMapRef {
8901 pub name: String,
8902 pub optional: bool,
8903 }
8904
8905 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8906 #[serde(rename_all = "camelCase")]
8907 pub struct ContainersItem {
8908 pub args: Vec<String>,
8909 pub command: Vec<String>,
8910 pub env: Vec<ContainersItemEnvItem>,
8911 pub env_from: Vec<ContainersItemEnvFromItem>,
8912 pub image: String,
8913 pub image_pull_policy: String,
8914 pub lifecycle: ContainersItemLifecycle,
8915 pub liveness_probe: ContainersItemLivenessProbe,
8916 pub name: String,
8917 pub ports: Vec<ContainersItemPortsItem>,
8918 pub readiness_probe: ContainersItemReadinessProbe,
8919 pub resources: ContainersItemResources,
8920 pub security_context: ContainersItemSecurityContext,
8921 pub startup_probe: ContainersItemStartupProbe,
8922 pub stdin: bool,
8923 pub stdin_once: bool,
8924 pub termination_message_path: String,
8925 pub termination_message_policy: String,
8926 pub tty: bool,
8927 pub volume_devices: Vec<ContainersItemVolumeDevicesItem>,
8928 pub volume_mounts: Vec<ContainersItemVolumeMountsItem>,
8929 pub working_dir: String,
8930 }
8931
8932 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8933 #[serde(rename_all = "camelCase")]
8934 pub struct CurrentBackgroundAnalysisRunStatus {
8935 pub message: String,
8936 pub name: String,
8937 pub status: String,
8938 }
8939
8940 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8941 #[serde(rename_all = "camelCase")]
8942 pub struct CurrentStepAnalysisRunStatus {
8943 pub message: String,
8944 pub name: String,
8945 pub status: String,
8946 }
8947
8948 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8949 #[serde(rename_all = "camelCase")]
8950 pub struct DestinationRule {
8951 pub canary_subset_name: String,
8952 pub name: String,
8953 pub stable_subset_name: String,
8954 }
8955
8956 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8957 #[serde(rename_all = "camelCase")]
8958 pub struct DnsConfig {
8959 pub nameservers: Vec<String>,
8960 pub options: Vec<OptionsItem>,
8961 pub searches: Vec<String>,
8962 }
8963
8964 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8965 #[serde(rename_all = "camelCase")]
8966 pub struct PostPromotionAnalysisDryRunItem {
8967 pub metric_name: String,
8968 }
8969
8970 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8971 #[serde(rename_all = "camelCase")]
8972 pub struct PrePromotionAnalysisDryRunItem {
8973 pub metric_name: String,
8974 }
8975
8976 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8977 #[serde(rename_all = "camelCase")]
8978 pub struct CanaryAnalysisDryRunItem {
8979 pub metric_name: String,
8980 }
8981
8982 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8983 #[serde(rename_all = "camelCase")]
8984 pub struct StepsItemAnalysisDryRunItem {
8985 pub metric_name: String,
8986 }
8987
8988 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8989 #[serde(rename_all = "camelCase")]
8990 pub struct ContainersItemEnvFromItem {
8991 pub config_map_ref: ContainersItemEnvFromItemConfigMapRef,
8992 pub prefix: String,
8993 pub secret_ref: ContainersItemEnvFromItemSecretRef,
8994 }
8995
8996 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
8997 #[serde(rename_all = "camelCase")]
8998 pub struct EphemeralContainersItemEnvFromItem {
8999 pub config_map_ref: EphemeralContainersItemEnvFromItemConfigMapRef,
9000 pub prefix: String,
9001 pub secret_ref: EphemeralContainersItemEnvFromItemSecretRef,
9002 }
9003
9004 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9005 #[serde(rename_all = "camelCase")]
9006 pub struct InitContainersItemEnvFromItem {
9007 pub config_map_ref: InitContainersItemEnvFromItemConfigMapRef,
9008 pub prefix: String,
9009 pub secret_ref: InitContainersItemEnvFromItemSecretRef,
9010 }
9011
9012 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9013 #[serde(rename_all = "camelCase")]
9014 pub struct ContainersItemEnvItem {
9015 pub name: String,
9016 pub value: String,
9017 pub value_from: ContainersItemEnvItemValueFrom,
9018 }
9019
9020 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9021 #[serde(rename_all = "camelCase")]
9022 pub struct EphemeralContainersItemEnvItem {
9023 pub name: String,
9024 pub value: String,
9025 pub value_from: EphemeralContainersItemEnvItemValueFrom,
9026 }
9027
9028 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9029 #[serde(rename_all = "camelCase")]
9030 pub struct InitContainersItemEnvItem {
9031 pub name: String,
9032 pub value: String,
9033 pub value_from: InitContainersItemEnvItemValueFrom,
9034 }
9035
9036 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9037 #[serde(rename_all = "camelCase")]
9038 pub struct EphemeralContainersItem {
9039 pub args: Vec<String>,
9040 pub command: Vec<String>,
9041 pub env: Vec<EphemeralContainersItemEnvItem>,
9042 pub env_from: Vec<EphemeralContainersItemEnvFromItem>,
9043 pub image: String,
9044 pub image_pull_policy: String,
9045 pub lifecycle: EphemeralContainersItemLifecycle,
9046 pub liveness_probe: EphemeralContainersItemLivenessProbe,
9047 pub name: String,
9048 pub ports: Vec<EphemeralContainersItemPortsItem>,
9049 pub readiness_probe: EphemeralContainersItemReadinessProbe,
9050 pub resources: EphemeralContainersItemResources,
9051 pub security_context: EphemeralContainersItemSecurityContext,
9052 pub startup_probe: EphemeralContainersItemStartupProbe,
9053 pub stdin: bool,
9054 pub stdin_once: bool,
9055 pub target_container_name: String,
9056 pub termination_message_path: String,
9057 pub termination_message_policy: String,
9058 pub tty: bool,
9059 pub volume_devices: Vec<EphemeralContainersItemVolumeDevicesItem>,
9060 pub volume_mounts: Vec<EphemeralContainersItemVolumeMountsItem>,
9061 pub working_dir: String,
9062 }
9063
9064 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9065 #[serde(rename_all = "camelCase")]
9066 pub struct ContainersItemLifecyclePostStartExec {
9067 pub command: Vec<String>,
9068 }
9069
9070 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9071 #[serde(rename_all = "camelCase")]
9072 pub struct ContainersItemLifecyclePreStopExec {
9073 pub command: Vec<String>,
9074 }
9075
9076 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9077 #[serde(rename_all = "camelCase")]
9078 pub struct ContainersItemLivenessProbeExec {
9079 pub command: Vec<String>,
9080 }
9081
9082 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9083 #[serde(rename_all = "camelCase")]
9084 pub struct ContainersItemReadinessProbeExec {
9085 pub command: Vec<String>,
9086 }
9087
9088 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9089 #[serde(rename_all = "camelCase")]
9090 pub struct ContainersItemStartupProbeExec {
9091 pub command: Vec<String>,
9092 }
9093
9094 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9095 #[serde(rename_all = "camelCase")]
9096 pub struct EphemeralContainersItemLifecyclePostStartExec {
9097 pub command: Vec<String>,
9098 }
9099
9100 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9101 #[serde(rename_all = "camelCase")]
9102 pub struct EphemeralContainersItemLifecyclePreStopExec {
9103 pub command: Vec<String>,
9104 }
9105
9106 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9107 #[serde(rename_all = "camelCase")]
9108 pub struct EphemeralContainersItemLivenessProbeExec {
9109 pub command: Vec<String>,
9110 }
9111
9112 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9113 #[serde(rename_all = "camelCase")]
9114 pub struct EphemeralContainersItemReadinessProbeExec {
9115 pub command: Vec<String>,
9116 }
9117
9118 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9119 #[serde(rename_all = "camelCase")]
9120 pub struct EphemeralContainersItemStartupProbeExec {
9121 pub command: Vec<String>,
9122 }
9123
9124 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9125 #[serde(rename_all = "camelCase")]
9126 pub struct InitContainersItemLifecyclePostStartExec {
9127 pub command: Vec<String>,
9128 }
9129
9130 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9131 #[serde(rename_all = "camelCase")]
9132 pub struct InitContainersItemLifecyclePreStopExec {
9133 pub command: Vec<String>,
9134 }
9135
9136 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9137 #[serde(rename_all = "camelCase")]
9138 pub struct InitContainersItemLivenessProbeExec {
9139 pub command: Vec<String>,
9140 }
9141
9142 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9143 #[serde(rename_all = "camelCase")]
9144 pub struct InitContainersItemReadinessProbeExec {
9145 pub command: Vec<String>,
9146 }
9147
9148 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9149 #[serde(rename_all = "camelCase")]
9150 pub struct InitContainersItemStartupProbeExec {
9151 pub command: Vec<String>,
9152 }
9153
9154 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9155 #[serde(rename_all = "camelCase")]
9156 pub struct Experiment {
9157 pub analyses: Vec<AnalysesItem>,
9158 pub duration: String,
9159 pub templates: Vec<ExperimentTemplatesItem>,
9160 }
9161
9162 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9163 #[serde(rename_all = "camelCase")]
9164 pub struct PostPromotionAnalysisArgsItemValueFromFieldRef {
9165 pub field_path: String,
9166 }
9167
9168 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9169 #[serde(rename_all = "camelCase")]
9170 pub struct PrePromotionAnalysisArgsItemValueFromFieldRef {
9171 pub field_path: String,
9172 }
9173
9174 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9175 #[serde(rename_all = "camelCase")]
9176 pub struct CanaryAnalysisArgsItemValueFromFieldRef {
9177 pub field_path: String,
9178 }
9179
9180 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9181 #[serde(rename_all = "camelCase")]
9182 pub struct StepsItemAnalysisArgsItemValueFromFieldRef {
9183 pub field_path: String,
9184 }
9185
9186 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9187 #[serde(rename_all = "camelCase")]
9188 pub struct AnalysesItemArgsItemValueFromFieldRef {
9189 pub field_path: String,
9190 }
9191
9192 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9193 #[serde(rename_all = "camelCase")]
9194 pub struct ContainersItemEnvItemValueFromFieldRef {
9195 pub api_version: String,
9196 pub field_path: String,
9197 }
9198
9199 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9200 #[serde(rename_all = "camelCase")]
9201 pub struct EphemeralContainersItemEnvItemValueFromFieldRef {
9202 pub api_version: String,
9203 pub field_path: String,
9204 }
9205
9206 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9207 #[serde(rename_all = "camelCase")]
9208 pub struct InitContainersItemEnvItemValueFromFieldRef {
9209 pub api_version: String,
9210 pub field_path: String,
9211 }
9212
9213 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9214 #[serde(rename_all = "camelCase")]
9215 pub struct ContainersItemLivenessProbeGrpc {
9216 pub port: i32,
9217 pub service: String,
9218 }
9219
9220 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9221 #[serde(rename_all = "camelCase")]
9222 pub struct ContainersItemReadinessProbeGrpc {
9223 pub port: i32,
9224 pub service: String,
9225 }
9226
9227 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9228 #[serde(rename_all = "camelCase")]
9229 pub struct ContainersItemStartupProbeGrpc {
9230 pub port: i32,
9231 pub service: String,
9232 }
9233
9234 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9235 #[serde(rename_all = "camelCase")]
9236 pub struct EphemeralContainersItemLivenessProbeGrpc {
9237 pub port: i32,
9238 pub service: String,
9239 }
9240
9241 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9242 #[serde(rename_all = "camelCase")]
9243 pub struct EphemeralContainersItemReadinessProbeGrpc {
9244 pub port: i32,
9245 pub service: String,
9246 }
9247
9248 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9249 #[serde(rename_all = "camelCase")]
9250 pub struct EphemeralContainersItemStartupProbeGrpc {
9251 pub port: i32,
9252 pub service: String,
9253 }
9254
9255 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9256 #[serde(rename_all = "camelCase")]
9257 pub struct InitContainersItemLivenessProbeGrpc {
9258 pub port: i32,
9259 pub service: String,
9260 }
9261
9262 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9263 #[serde(rename_all = "camelCase")]
9264 pub struct InitContainersItemReadinessProbeGrpc {
9265 pub port: i32,
9266 pub service: String,
9267 }
9268
9269 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9270 #[serde(rename_all = "camelCase")]
9271 pub struct InitContainersItemStartupProbeGrpc {
9272 pub port: i32,
9273 pub service: String,
9274 }
9275
9276 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9277 #[serde(rename_all = "camelCase")]
9278 pub struct HeaderValue {
9279 pub exact: String,
9280 pub prefix: String,
9281 pub regex: String,
9282 }
9283
9284 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9285 #[serde(rename_all = "camelCase")]
9286 pub struct Headers {
9287 pub properties: std::collections::HashMap<String, Value>,
9288 }
9289
9290 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9291 #[serde(rename_all = "camelCase")]
9292 pub struct HostAliasesItem {
9293 pub hostnames: Vec<String>,
9294 pub ip: String,
9295 }
9296
9297 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9298 #[serde(rename_all = "camelCase")]
9299 pub struct ContainersItemLifecyclePostStartHttpGet {
9300 pub host: String,
9301 pub http_headers: Vec<ContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
9302 pub path: String,
9303 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9304 pub scheme: String,
9305 }
9306
9307 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9308 #[serde(rename_all = "camelCase")]
9309 pub struct ContainersItemLifecyclePreStopHttpGet {
9310 pub host: String,
9311 pub http_headers: Vec<ContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
9312 pub path: String,
9313 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9314 pub scheme: String,
9315 }
9316
9317 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9318 #[serde(rename_all = "camelCase")]
9319 pub struct ContainersItemLivenessProbeHttpGet {
9320 pub host: String,
9321 pub http_headers: Vec<ContainersItemLivenessProbeHttpGetHttpHeadersItem>,
9322 pub path: String,
9323 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9324 pub scheme: String,
9325 }
9326
9327 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9328 #[serde(rename_all = "camelCase")]
9329 pub struct ContainersItemReadinessProbeHttpGet {
9330 pub host: String,
9331 pub http_headers: Vec<ContainersItemReadinessProbeHttpGetHttpHeadersItem>,
9332 pub path: String,
9333 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9334 pub scheme: String,
9335 }
9336
9337 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9338 #[serde(rename_all = "camelCase")]
9339 pub struct ContainersItemStartupProbeHttpGet {
9340 pub host: String,
9341 pub http_headers: Vec<ContainersItemStartupProbeHttpGetHttpHeadersItem>,
9342 pub path: String,
9343 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9344 pub scheme: String,
9345 }
9346
9347 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9348 #[serde(rename_all = "camelCase")]
9349 pub struct EphemeralContainersItemLifecyclePostStartHttpGet {
9350 pub host: String,
9351 pub http_headers:
9352 Vec<EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
9353 pub path: String,
9354 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9355 pub scheme: String,
9356 }
9357
9358 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9359 #[serde(rename_all = "camelCase")]
9360 pub struct EphemeralContainersItemLifecyclePreStopHttpGet {
9361 pub host: String,
9362 pub http_headers:
9363 Vec<EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
9364 pub path: String,
9365 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9366 pub scheme: String,
9367 }
9368
9369 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9370 #[serde(rename_all = "camelCase")]
9371 pub struct EphemeralContainersItemLivenessProbeHttpGet {
9372 pub host: String,
9373 pub http_headers: Vec<EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem>,
9374 pub path: String,
9375 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9376 pub scheme: String,
9377 }
9378
9379 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9380 #[serde(rename_all = "camelCase")]
9381 pub struct EphemeralContainersItemReadinessProbeHttpGet {
9382 pub host: String,
9383 pub http_headers: Vec<EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem>,
9384 pub path: String,
9385 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9386 pub scheme: String,
9387 }
9388
9389 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9390 #[serde(rename_all = "camelCase")]
9391 pub struct EphemeralContainersItemStartupProbeHttpGet {
9392 pub host: String,
9393 pub http_headers: Vec<EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem>,
9394 pub path: String,
9395 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9396 pub scheme: String,
9397 }
9398
9399 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9400 #[serde(rename_all = "camelCase")]
9401 pub struct InitContainersItemLifecyclePostStartHttpGet {
9402 pub host: String,
9403 pub http_headers: Vec<InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem>,
9404 pub path: String,
9405 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9406 pub scheme: String,
9407 }
9408
9409 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9410 #[serde(rename_all = "camelCase")]
9411 pub struct InitContainersItemLifecyclePreStopHttpGet {
9412 pub host: String,
9413 pub http_headers: Vec<InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem>,
9414 pub path: String,
9415 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9416 pub scheme: String,
9417 }
9418
9419 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9420 #[serde(rename_all = "camelCase")]
9421 pub struct InitContainersItemLivenessProbeHttpGet {
9422 pub host: String,
9423 pub http_headers: Vec<InitContainersItemLivenessProbeHttpGetHttpHeadersItem>,
9424 pub path: String,
9425 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9426 pub scheme: String,
9427 }
9428
9429 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9430 #[serde(rename_all = "camelCase")]
9431 pub struct InitContainersItemReadinessProbeHttpGet {
9432 pub host: String,
9433 pub http_headers: Vec<InitContainersItemReadinessProbeHttpGetHttpHeadersItem>,
9434 pub path: String,
9435 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9436 pub scheme: String,
9437 }
9438
9439 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9440 #[serde(rename_all = "camelCase")]
9441 pub struct InitContainersItemStartupProbeHttpGet {
9442 pub host: String,
9443 pub http_headers: Vec<InitContainersItemStartupProbeHttpGetHttpHeadersItem>,
9444 pub path: String,
9445 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
9446 pub scheme: String,
9447 }
9448
9449 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9450 #[serde(rename_all = "camelCase")]
9451 pub struct ContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
9452 pub name: String,
9453 pub value: String,
9454 }
9455
9456 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9457 #[serde(rename_all = "camelCase")]
9458 pub struct ContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
9459 pub name: String,
9460 pub value: String,
9461 }
9462
9463 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9464 #[serde(rename_all = "camelCase")]
9465 pub struct ContainersItemLivenessProbeHttpGetHttpHeadersItem {
9466 pub name: String,
9467 pub value: String,
9468 }
9469
9470 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9471 #[serde(rename_all = "camelCase")]
9472 pub struct ContainersItemReadinessProbeHttpGetHttpHeadersItem {
9473 pub name: String,
9474 pub value: String,
9475 }
9476
9477 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9478 #[serde(rename_all = "camelCase")]
9479 pub struct ContainersItemStartupProbeHttpGetHttpHeadersItem {
9480 pub name: String,
9481 pub value: String,
9482 }
9483
9484 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9485 #[serde(rename_all = "camelCase")]
9486 pub struct EphemeralContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
9487 pub name: String,
9488 pub value: String,
9489 }
9490
9491 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9492 #[serde(rename_all = "camelCase")]
9493 pub struct EphemeralContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
9494 pub name: String,
9495 pub value: String,
9496 }
9497
9498 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9499 #[serde(rename_all = "camelCase")]
9500 pub struct EphemeralContainersItemLivenessProbeHttpGetHttpHeadersItem {
9501 pub name: String,
9502 pub value: String,
9503 }
9504
9505 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9506 #[serde(rename_all = "camelCase")]
9507 pub struct EphemeralContainersItemReadinessProbeHttpGetHttpHeadersItem {
9508 pub name: String,
9509 pub value: String,
9510 }
9511
9512 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9513 #[serde(rename_all = "camelCase")]
9514 pub struct EphemeralContainersItemStartupProbeHttpGetHttpHeadersItem {
9515 pub name: String,
9516 pub value: String,
9517 }
9518
9519 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9520 #[serde(rename_all = "camelCase")]
9521 pub struct InitContainersItemLifecyclePostStartHttpGetHttpHeadersItem {
9522 pub name: String,
9523 pub value: String,
9524 }
9525
9526 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9527 #[serde(rename_all = "camelCase")]
9528 pub struct InitContainersItemLifecyclePreStopHttpGetHttpHeadersItem {
9529 pub name: String,
9530 pub value: String,
9531 }
9532
9533 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9534 #[serde(rename_all = "camelCase")]
9535 pub struct InitContainersItemLivenessProbeHttpGetHttpHeadersItem {
9536 pub name: String,
9537 pub value: String,
9538 }
9539
9540 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9541 #[serde(rename_all = "camelCase")]
9542 pub struct InitContainersItemReadinessProbeHttpGetHttpHeadersItem {
9543 pub name: String,
9544 pub value: String,
9545 }
9546
9547 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9548 #[serde(rename_all = "camelCase")]
9549 pub struct InitContainersItemStartupProbeHttpGetHttpHeadersItem {
9550 pub name: String,
9551 pub value: String,
9552 }
9553
9554 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9555 #[serde(rename_all = "camelCase")]
9556 pub struct ImagePullSecretsItem {
9557 pub name: String,
9558 }
9559
9560 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9561 #[serde(rename_all = "camelCase")]
9562 pub struct InitContainersItem {
9563 pub args: Vec<String>,
9564 pub command: Vec<String>,
9565 pub env: Vec<InitContainersItemEnvItem>,
9566 pub env_from: Vec<InitContainersItemEnvFromItem>,
9567 pub image: String,
9568 pub image_pull_policy: String,
9569 pub lifecycle: InitContainersItemLifecycle,
9570 pub liveness_probe: InitContainersItemLivenessProbe,
9571 pub name: String,
9572 pub ports: Vec<InitContainersItemPortsItem>,
9573 pub readiness_probe: InitContainersItemReadinessProbe,
9574 pub resources: InitContainersItemResources,
9575 pub security_context: InitContainersItemSecurityContext,
9576 pub startup_probe: InitContainersItemStartupProbe,
9577 pub stdin: bool,
9578 pub stdin_once: bool,
9579 pub termination_message_path: String,
9580 pub termination_message_policy: String,
9581 pub tty: bool,
9582 pub volume_devices: Vec<InitContainersItemVolumeDevicesItem>,
9583 pub volume_mounts: Vec<InitContainersItemVolumeMountsItem>,
9584 pub working_dir: String,
9585 }
9586
9587 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9588 #[serde(rename_all = "camelCase")]
9589 pub struct Istio {
9590 pub destination_rule: DestinationRule,
9591 pub virtual_service: IstioVirtualService,
9592 pub virtual_services: Vec<VirtualServicesItem>,
9593 }
9594
9595 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9596 #[serde(rename_all = "camelCase")]
9597 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
9598 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
9599 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
9600 }
9601
9602 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9603 #[serde(rename_all = "camelCase")]
9604 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
9605 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
9606 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
9607 }
9608
9609 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9610 #[serde(rename_all = "camelCase")]
9611 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector {
9612 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem>,
9613 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels,
9614 }
9615
9616 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9617 #[serde(rename_all = "camelCase")]
9618 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector {
9619 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem>,
9620 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels,
9621 }
9622
9623 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9624 #[serde(rename_all = "camelCase")]
9625 pub struct TopologySpreadConstraintsItemLabelSelector {
9626 pub match_expressions:
9627 Vec<TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem>,
9628 pub match_labels: TopologySpreadConstraintsItemLabelSelectorMatchLabels,
9629 }
9630
9631 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9632 #[serde(rename_all = "camelCase")]
9633 pub struct ActiveMetadataLabels {
9634 pub properties: std::collections::HashMap<String, String>,
9635 }
9636
9637 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9638 #[serde(rename_all = "camelCase")]
9639 pub struct PreviewMetadataLabels {
9640 pub properties: std::collections::HashMap<String, String>,
9641 }
9642
9643 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9644 #[serde(rename_all = "camelCase")]
9645 pub struct CanaryMetadataLabels {
9646 pub properties: std::collections::HashMap<String, String>,
9647 }
9648
9649 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9650 #[serde(rename_all = "camelCase")]
9651 pub struct StableMetadataLabels {
9652 pub properties: std::collections::HashMap<String, String>,
9653 }
9654
9655 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9656 #[serde(rename_all = "camelCase")]
9657 pub struct TemplatesItemMetadataLabels {
9658 pub properties: std::collections::HashMap<String, String>,
9659 }
9660
9661 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9662 #[serde(rename_all = "camelCase")]
9663 pub struct TemplateMetadataLabels {
9664 pub properties: std::collections::HashMap<String, String>,
9665 }
9666
9667 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9668 #[serde(rename_all = "camelCase")]
9669 pub struct ContainersItemLifecycle {
9670 pub post_start: ContainersItemLifecyclePostStart,
9671 pub pre_stop: ContainersItemLifecyclePreStop,
9672 }
9673
9674 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9675 #[serde(rename_all = "camelCase")]
9676 pub struct EphemeralContainersItemLifecycle {
9677 pub post_start: EphemeralContainersItemLifecyclePostStart,
9678 pub pre_stop: EphemeralContainersItemLifecyclePreStop,
9679 }
9680
9681 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9682 #[serde(rename_all = "camelCase")]
9683 pub struct InitContainersItemLifecycle {
9684 pub post_start: InitContainersItemLifecyclePostStart,
9685 pub pre_stop: InitContainersItemLifecyclePreStop,
9686 }
9687
9688 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9689 #[serde(rename_all = "camelCase")]
9690 pub struct ContainersItemLivenessProbe {
9691 pub exec: ContainersItemLivenessProbeExec,
9692 pub failure_threshold: i32,
9693 pub grpc: ContainersItemLivenessProbeGrpc,
9694 pub http_get: ContainersItemLivenessProbeHttpGet,
9695 pub initial_delay_seconds: i32,
9696 pub period_seconds: i32,
9697 pub success_threshold: i32,
9698 pub tcp_socket: ContainersItemLivenessProbeTcpSocket,
9699 pub termination_grace_period_seconds: i64,
9700 pub timeout_seconds: i32,
9701 }
9702
9703 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9704 #[serde(rename_all = "camelCase")]
9705 pub struct EphemeralContainersItemLivenessProbe {
9706 pub exec: EphemeralContainersItemLivenessProbeExec,
9707 pub failure_threshold: i32,
9708 pub grpc: EphemeralContainersItemLivenessProbeGrpc,
9709 pub http_get: EphemeralContainersItemLivenessProbeHttpGet,
9710 pub initial_delay_seconds: i32,
9711 pub period_seconds: i32,
9712 pub success_threshold: i32,
9713 pub tcp_socket: EphemeralContainersItemLivenessProbeTcpSocket,
9714 pub termination_grace_period_seconds: i64,
9715 pub timeout_seconds: i32,
9716 }
9717
9718 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9719 #[serde(rename_all = "camelCase")]
9720 pub struct InitContainersItemLivenessProbe {
9721 pub exec: InitContainersItemLivenessProbeExec,
9722 pub failure_threshold: i32,
9723 pub grpc: InitContainersItemLivenessProbeGrpc,
9724 pub http_get: InitContainersItemLivenessProbeHttpGet,
9725 pub initial_delay_seconds: i32,
9726 pub period_seconds: i32,
9727 pub success_threshold: i32,
9728 pub tcp_socket: InitContainersItemLivenessProbeTcpSocket,
9729 pub termination_grace_period_seconds: i64,
9730 pub timeout_seconds: i32,
9731 }
9732
9733 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9734 #[serde(rename_all = "camelCase")]
9735 pub struct LoadBalancer {
9736 pub arn: String,
9737 pub name: String,
9738 }
9739
9740 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9741 #[serde(rename_all = "camelCase")]
9742 pub struct ManagedRoutesItem {
9743 pub name: String,
9744 }
9745
9746 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9747 #[serde(rename_all = "camelCase")]
9748 pub struct SpecSelectorMatchExpressionsItem {
9749 pub key: String,
9750 pub operator: String,
9751 pub values: Vec<String>,
9752 }
9753
9754 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9755 #[serde(rename_all = "camelCase")]
9756 pub struct TemplatesItemSelectorMatchExpressionsItem {
9757 pub key: String,
9758 pub operator: String,
9759 pub values: Vec<String>,
9760 }
9761
9762 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9763 #[serde(rename_all = "camelCase")]
9764 pub struct PreferenceMatchExpressionsItem {
9765 pub key: String,
9766 pub operator: String,
9767 pub values: Vec<String>,
9768 }
9769
9770 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9771 #[serde(rename_all = "camelCase")]
9772 pub struct NodeSelectorTermsItemMatchExpressionsItem {
9773 pub key: String,
9774 pub operator: String,
9775 pub values: Vec<String>,
9776 }
9777
9778 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9779 #[serde(rename_all = "camelCase")]
9780 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
9781 {
9782 pub key: String,
9783 pub operator: String,
9784 pub values: Vec<String>,
9785 }
9786
9787 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9788 #[serde(rename_all = "camelCase")]
9789 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
9790 {
9791 pub key: String,
9792 pub operator: String,
9793 pub values: Vec<String>,
9794 }
9795
9796 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9797 #[serde(rename_all = "camelCase")]
9798 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
9799 {
9800 pub key: String,
9801 pub operator: String,
9802 pub values: Vec<String>,
9803 }
9804
9805 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9806 #[serde(rename_all = "camelCase")]
9807 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
9808 {
9809 pub key: String,
9810 pub operator: String,
9811 pub values: Vec<String>,
9812 }
9813
9814 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9815 #[serde(rename_all = "camelCase")]
9816 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchExpressionsItem
9817 {
9818 pub key: String,
9819 pub operator: String,
9820 pub values: Vec<String>,
9821 }
9822
9823 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9824 #[serde(rename_all = "camelCase")]
9825 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem
9826 {
9827 pub key: String,
9828 pub operator: String,
9829 pub values: Vec<String>,
9830 }
9831
9832 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9833 #[serde(rename_all = "camelCase")]
9834 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchExpressionsItem
9835 {
9836 pub key: String,
9837 pub operator: String,
9838 pub values: Vec<String>,
9839 }
9840
9841 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9842 #[serde(rename_all = "camelCase")]
9843 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem
9844 {
9845 pub key: String,
9846 pub operator: String,
9847 pub values: Vec<String>,
9848 }
9849
9850 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9851 #[serde(rename_all = "camelCase")]
9852 pub struct TopologySpreadConstraintsItemLabelSelectorMatchExpressionsItem {
9853 pub key: String,
9854 pub operator: String,
9855 pub values: Vec<String>,
9856 }
9857
9858 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9859 #[serde(rename_all = "camelCase")]
9860 pub struct PreferenceMatchFieldsItem {
9861 pub key: String,
9862 pub operator: String,
9863 pub values: Vec<String>,
9864 }
9865
9866 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9867 #[serde(rename_all = "camelCase")]
9868 pub struct NodeSelectorTermsItemMatchFieldsItem {
9869 pub key: String,
9870 pub operator: String,
9871 pub values: Vec<String>,
9872 }
9873
9874 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9875 #[serde(rename_all = "camelCase")]
9876 pub struct SetHeaderRouteMatchItem {
9877 pub header_name: String,
9878 pub header_value: HeaderValue,
9879 }
9880
9881 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9882 #[serde(rename_all = "camelCase")]
9883 pub struct SetMirrorRouteMatchItem {
9884 pub headers: Headers,
9885 pub method: Method,
9886 pub path: Path,
9887 }
9888
9889 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9890 #[serde(rename_all = "camelCase")]
9891 pub struct SpecSelectorMatchLabels {
9892 pub properties: std::collections::HashMap<String, String>,
9893 }
9894
9895 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9896 #[serde(rename_all = "camelCase")]
9897 pub struct TemplatesItemSelectorMatchLabels {
9898 pub properties: std::collections::HashMap<String, String>,
9899 }
9900
9901 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9902 #[serde(rename_all = "camelCase")]
9903 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
9904 {
9905 pub properties: std::collections::HashMap<String, String>,
9906 }
9907
9908 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9909 #[serde(rename_all = "camelCase")]
9910 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
9911 {
9912 pub properties: std::collections::HashMap<String, String>,
9913 }
9914
9915 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9916 #[serde(rename_all = "camelCase")]
9917 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels {
9918 pub properties: std::collections::HashMap<String, String>,
9919 }
9920
9921 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9922 #[serde(rename_all = "camelCase")]
9923 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
9924 {
9925 pub properties: std::collections::HashMap<String, String>,
9926 }
9927
9928 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9929 #[serde(rename_all = "camelCase")]
9930 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelectorMatchLabels
9931 {
9932 pub properties: std::collections::HashMap<String, String>,
9933 }
9934
9935 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9936 #[serde(rename_all = "camelCase")]
9937 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels
9938 {
9939 pub properties: std::collections::HashMap<String, String>,
9940 }
9941
9942 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9943 #[serde(rename_all = "camelCase")]
9944 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelectorMatchLabels
9945 {
9946 pub properties: std::collections::HashMap<String, String>,
9947 }
9948
9949 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9950 #[serde(rename_all = "camelCase")]
9951 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels
9952 {
9953 pub properties: std::collections::HashMap<String, String>,
9954 }
9955
9956 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9957 #[serde(rename_all = "camelCase")]
9958 pub struct TopologySpreadConstraintsItemLabelSelectorMatchLabels {
9959 pub properties: std::collections::HashMap<String, String>,
9960 }
9961
9962 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9963 #[serde(rename_all = "camelCase")]
9964 pub struct PostPromotionAnalysisMeasurementRetentionItem {
9965 pub limit: i32,
9966 pub metric_name: String,
9967 }
9968
9969 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9970 #[serde(rename_all = "camelCase")]
9971 pub struct PrePromotionAnalysisMeasurementRetentionItem {
9972 pub limit: i32,
9973 pub metric_name: String,
9974 }
9975
9976 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9977 #[serde(rename_all = "camelCase")]
9978 pub struct CanaryAnalysisMeasurementRetentionItem {
9979 pub limit: i32,
9980 pub metric_name: String,
9981 }
9982
9983 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9984 #[serde(rename_all = "camelCase")]
9985 pub struct StepsItemAnalysisMeasurementRetentionItem {
9986 pub limit: i32,
9987 pub metric_name: String,
9988 }
9989
9990 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9991 #[serde(rename_all = "camelCase")]
9992 pub struct TemplatesItemMetadata {
9993 pub annotations: TemplatesItemMetadataAnnotations,
9994 pub labels: TemplatesItemMetadataLabels,
9995 }
9996
9997 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
9998 #[serde(rename_all = "camelCase")]
9999 pub struct TemplateMetadata {
10000 pub annotations: TemplateMetadataAnnotations,
10001 pub labels: TemplateMetadataLabels,
10002 }
10003
10004 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10005 #[serde(rename_all = "camelCase")]
10006 pub struct Method {
10007 pub exact: String,
10008 pub prefix: String,
10009 pub regex: String,
10010 }
10011
10012 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10013 #[serde(rename_all = "camelCase")]
10014 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
10015 pub match_expressions: Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
10016 pub match_labels: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
10017 }
10018
10019 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10020 #[serde(rename_all = "camelCase")]
10021 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
10022 pub match_expressions: Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
10023 pub match_labels: PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
10024 }
10025
10026 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10027 #[serde(rename_all = "camelCase")]
10028 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector {
10029 pub match_expressions: Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchExpressionsItem>,
10030 pub match_labels: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelectorMatchLabels,
10031 }
10032
10033 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10034 #[serde(rename_all = "camelCase")]
10035 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector {
10036 pub match_expressions: Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchExpressionsItem>,
10037 pub match_labels: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelectorMatchLabels,
10038 }
10039
10040 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10041 #[serde(rename_all = "camelCase")]
10042 pub struct Nginx {
10043 pub additional_ingress_annotations: AdditionalIngressAnnotations,
10044 pub annotation_prefix: String,
10045 pub stable_ingress: String,
10046 }
10047
10048 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10049 #[serde(rename_all = "camelCase")]
10050 pub struct NodeAffinity {
10051 pub preferred_during_scheduling_ignored_during_execution:
10052 Vec<NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
10053 pub required_during_scheduling_ignored_during_execution:
10054 NodeAffinityRequiredDuringSchedulingIgnoredDuringExecution,
10055 }
10056
10057 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10058 #[serde(rename_all = "camelCase")]
10059 pub struct NodeSelector {
10060 pub properties: std::collections::HashMap<String, String>,
10061 }
10062
10063 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10064 #[serde(rename_all = "camelCase")]
10065 pub struct NodeSelectorTermsItem {
10066 pub match_expressions: Vec<NodeSelectorTermsItemMatchExpressionsItem>,
10067 pub match_fields: Vec<NodeSelectorTermsItemMatchFieldsItem>,
10068 }
10069
10070 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10071 #[serde(rename_all = "camelCase")]
10072 pub struct OptionsItem {
10073 pub name: String,
10074 pub value: String,
10075 }
10076
10077 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10078 #[serde(rename_all = "camelCase")]
10079 pub struct Os {
10080 pub name: String,
10081 }
10082
10083 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10084 #[serde(rename_all = "camelCase")]
10085 pub struct Overhead {
10086 pub properties: std::collections::HashMap<
10087 String,
10088 k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10089 >,
10090 }
10091
10092 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10093 #[serde(rename_all = "camelCase")]
10094 pub struct Path {
10095 pub exact: String,
10096 pub prefix: String,
10097 pub regex: String,
10098 }
10099
10100 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10101 #[serde(rename_all = "camelCase")]
10102 pub struct Pause {
10103 pub duration: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10104 }
10105
10106 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10107 #[serde(rename_all = "camelCase")]
10108 pub struct PauseConditionsItem {
10109 pub reason: String,
10110 pub start_time: String,
10111 }
10112
10113 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10114 #[serde(rename_all = "camelCase")]
10115 pub struct PingPong {
10116 pub ping_service: String,
10117 pub pong_service: String,
10118 }
10119
10120 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10121 #[serde(rename_all = "camelCase")]
10122 pub struct PodAffinity {
10123 pub preferred_during_scheduling_ignored_during_execution:
10124 Vec<PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
10125 pub required_during_scheduling_ignored_during_execution:
10126 Vec<PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
10127 }
10128
10129 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10130 #[serde(rename_all = "camelCase")]
10131 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
10132 pub label_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
10133 pub namespace_selector: PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
10134 pub namespaces: Vec<String>,
10135 pub topology_key: String,
10136 }
10137
10138 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10139 #[serde(rename_all = "camelCase")]
10140 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm {
10141 pub label_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermLabelSelector,
10142 pub namespace_selector: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTermNamespaceSelector,
10143 pub namespaces: Vec<String>,
10144 pub topology_key: String,
10145 }
10146
10147 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10148 #[serde(rename_all = "camelCase")]
10149 pub struct PodAntiAffinity {
10150 pub preferred_during_scheduling_ignored_during_execution:
10151 Vec<PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem>,
10152 pub required_during_scheduling_ignored_during_execution:
10153 Vec<PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem>,
10154 }
10155
10156 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10157 #[serde(rename_all = "camelCase")]
10158 pub struct ContainersItemPortsItem {
10159 pub container_port: i32,
10160 pub host_i_p: String,
10161 pub host_port: i32,
10162 pub name: String,
10163 pub protocol: String,
10164 }
10165
10166 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10167 #[serde(rename_all = "camelCase")]
10168 pub struct EphemeralContainersItemPortsItem {
10169 pub container_port: i32,
10170 pub host_i_p: String,
10171 pub host_port: i32,
10172 pub name: String,
10173 pub protocol: String,
10174 }
10175
10176 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10177 #[serde(rename_all = "camelCase")]
10178 pub struct InitContainersItemPortsItem {
10179 pub container_port: i32,
10180 pub host_i_p: String,
10181 pub host_port: i32,
10182 pub name: String,
10183 pub protocol: String,
10184 }
10185
10186 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10187 #[serde(rename_all = "camelCase")]
10188 pub struct PostPromotionAnalysis {
10189 pub args: Vec<PostPromotionAnalysisArgsItem>,
10190 pub dry_run: Vec<PostPromotionAnalysisDryRunItem>,
10191 pub measurement_retention: Vec<PostPromotionAnalysisMeasurementRetentionItem>,
10192 pub templates: Vec<PostPromotionAnalysisTemplatesItem>,
10193 }
10194
10195 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10196 #[serde(rename_all = "camelCase")]
10197 pub struct PostPromotionAnalysisRunStatus {
10198 pub message: String,
10199 pub name: String,
10200 pub status: String,
10201 }
10202
10203 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10204 #[serde(rename_all = "camelCase")]
10205 pub struct ContainersItemLifecyclePostStart {
10206 pub exec: ContainersItemLifecyclePostStartExec,
10207 pub http_get: ContainersItemLifecyclePostStartHttpGet,
10208 pub tcp_socket: ContainersItemLifecyclePostStartTcpSocket,
10209 }
10210
10211 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10212 #[serde(rename_all = "camelCase")]
10213 pub struct EphemeralContainersItemLifecyclePostStart {
10214 pub exec: EphemeralContainersItemLifecyclePostStartExec,
10215 pub http_get: EphemeralContainersItemLifecyclePostStartHttpGet,
10216 pub tcp_socket: EphemeralContainersItemLifecyclePostStartTcpSocket,
10217 }
10218
10219 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10220 #[serde(rename_all = "camelCase")]
10221 pub struct InitContainersItemLifecyclePostStart {
10222 pub exec: InitContainersItemLifecyclePostStartExec,
10223 pub http_get: InitContainersItemLifecyclePostStartHttpGet,
10224 pub tcp_socket: InitContainersItemLifecyclePostStartTcpSocket,
10225 }
10226
10227 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10228 #[serde(rename_all = "camelCase")]
10229 pub struct PrePromotionAnalysis {
10230 pub args: Vec<PrePromotionAnalysisArgsItem>,
10231 pub dry_run: Vec<PrePromotionAnalysisDryRunItem>,
10232 pub measurement_retention: Vec<PrePromotionAnalysisMeasurementRetentionItem>,
10233 pub templates: Vec<PrePromotionAnalysisTemplatesItem>,
10234 }
10235
10236 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10237 #[serde(rename_all = "camelCase")]
10238 pub struct PrePromotionAnalysisRunStatus {
10239 pub message: String,
10240 pub name: String,
10241 pub status: String,
10242 }
10243
10244 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10245 #[serde(rename_all = "camelCase")]
10246 pub struct ContainersItemLifecyclePreStop {
10247 pub exec: ContainersItemLifecyclePreStopExec,
10248 pub http_get: ContainersItemLifecyclePreStopHttpGet,
10249 pub tcp_socket: ContainersItemLifecyclePreStopTcpSocket,
10250 }
10251
10252 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10253 #[serde(rename_all = "camelCase")]
10254 pub struct EphemeralContainersItemLifecyclePreStop {
10255 pub exec: EphemeralContainersItemLifecyclePreStopExec,
10256 pub http_get: EphemeralContainersItemLifecyclePreStopHttpGet,
10257 pub tcp_socket: EphemeralContainersItemLifecyclePreStopTcpSocket,
10258 }
10259
10260 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10261 #[serde(rename_all = "camelCase")]
10262 pub struct InitContainersItemLifecyclePreStop {
10263 pub exec: InitContainersItemLifecyclePreStopExec,
10264 pub http_get: InitContainersItemLifecyclePreStopHttpGet,
10265 pub tcp_socket: InitContainersItemLifecyclePreStopTcpSocket,
10266 }
10267
10268 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10269 #[serde(rename_all = "camelCase")]
10270 pub struct Preference {
10271 pub match_expressions: Vec<PreferenceMatchExpressionsItem>,
10272 pub match_fields: Vec<PreferenceMatchFieldsItem>,
10273 }
10274
10275 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10276 #[serde(rename_all = "camelCase")]
10277 pub struct BlueGreenAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution {
10278 pub weight: i32,
10279 }
10280
10281 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10282 #[serde(rename_all = "camelCase")]
10283 pub struct CanaryAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution {
10284 pub weight: i32,
10285 }
10286
10287 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10288 #[serde(rename_all = "camelCase")]
10289 pub struct NodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
10290 pub preference: Preference,
10291 pub weight: i32,
10292 }
10293
10294 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10295 #[serde(rename_all = "camelCase")]
10296 pub struct PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
10297 pub pod_affinity_term:
10298 PodAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
10299 pub weight: i32,
10300 }
10301
10302 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10303 #[serde(rename_all = "camelCase")]
10304 pub struct PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItem {
10305 pub pod_affinity_term: PodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionItemPodAffinityTerm,
10306 pub weight: i32,
10307 }
10308
10309 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10310 #[serde(rename_all = "camelCase")]
10311 pub struct PreviewMetadata {
10312 pub annotations: PreviewMetadataAnnotations,
10313 pub labels: PreviewMetadataLabels,
10314 }
10315
10316 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10317 #[serde(rename_all = "camelCase")]
10318 pub struct ReadinessGatesItem {
10319 pub condition_type: String,
10320 }
10321
10322 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10323 #[serde(rename_all = "camelCase")]
10324 pub struct ContainersItemReadinessProbe {
10325 pub exec: ContainersItemReadinessProbeExec,
10326 pub failure_threshold: i32,
10327 pub grpc: ContainersItemReadinessProbeGrpc,
10328 pub http_get: ContainersItemReadinessProbeHttpGet,
10329 pub initial_delay_seconds: i32,
10330 pub period_seconds: i32,
10331 pub success_threshold: i32,
10332 pub tcp_socket: ContainersItemReadinessProbeTcpSocket,
10333 pub termination_grace_period_seconds: i64,
10334 pub timeout_seconds: i32,
10335 }
10336
10337 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10338 #[serde(rename_all = "camelCase")]
10339 pub struct EphemeralContainersItemReadinessProbe {
10340 pub exec: EphemeralContainersItemReadinessProbeExec,
10341 pub failure_threshold: i32,
10342 pub grpc: EphemeralContainersItemReadinessProbeGrpc,
10343 pub http_get: EphemeralContainersItemReadinessProbeHttpGet,
10344 pub initial_delay_seconds: i32,
10345 pub period_seconds: i32,
10346 pub success_threshold: i32,
10347 pub tcp_socket: EphemeralContainersItemReadinessProbeTcpSocket,
10348 pub termination_grace_period_seconds: i64,
10349 pub timeout_seconds: i32,
10350 }
10351
10352 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10353 #[serde(rename_all = "camelCase")]
10354 pub struct InitContainersItemReadinessProbe {
10355 pub exec: InitContainersItemReadinessProbeExec,
10356 pub failure_threshold: i32,
10357 pub grpc: InitContainersItemReadinessProbeGrpc,
10358 pub http_get: InitContainersItemReadinessProbeHttpGet,
10359 pub initial_delay_seconds: i32,
10360 pub period_seconds: i32,
10361 pub success_threshold: i32,
10362 pub tcp_socket: InitContainersItemReadinessProbeTcpSocket,
10363 pub termination_grace_period_seconds: i64,
10364 pub timeout_seconds: i32,
10365 }
10366
10367 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10368 #[serde(rename_all = "camelCase")]
10369 pub struct BlueGreenAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution {
10370 pub properties: serde_json::Map<String, serde_json::Value>,
10371 }
10372
10373 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10374 #[serde(rename_all = "camelCase")]
10375 pub struct CanaryAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution {
10376 pub properties: serde_json::Map<String, serde_json::Value>,
10377 }
10378
10379 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10380 #[serde(rename_all = "camelCase")]
10381 pub struct NodeAffinityRequiredDuringSchedulingIgnoredDuringExecution {
10382 pub node_selector_terms: Vec<NodeSelectorTermsItem>,
10383 }
10384
10385 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10386 #[serde(rename_all = "camelCase")]
10387 pub struct PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
10388 pub label_selector:
10389 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
10390 pub namespace_selector:
10391 PodAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
10392 pub namespaces: Vec<String>,
10393 pub topology_key: String,
10394 }
10395
10396 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10397 #[serde(rename_all = "camelCase")]
10398 pub struct PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItem {
10399 pub label_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemLabelSelector,
10400 pub namespace_selector: PodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionItemNamespaceSelector,
10401 pub namespaces: Vec<String>,
10402 pub topology_key: String,
10403 }
10404
10405 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10406 #[serde(rename_all = "camelCase")]
10407 pub struct ContainersItemEnvItemValueFromResourceFieldRef {
10408 pub container_name: String,
10409 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10410 pub resource: String,
10411 }
10412
10413 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10414 #[serde(rename_all = "camelCase")]
10415 pub struct EphemeralContainersItemEnvItemValueFromResourceFieldRef {
10416 pub container_name: String,
10417 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10418 pub resource: String,
10419 }
10420
10421 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10422 #[serde(rename_all = "camelCase")]
10423 pub struct InitContainersItemEnvItemValueFromResourceFieldRef {
10424 pub container_name: String,
10425 pub divisor: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10426 pub resource: String,
10427 }
10428
10429 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10430 #[serde(rename_all = "camelCase")]
10431 pub struct ContainersItemResources {
10432 pub limits: serde_json::Map<String, serde_json::Value>,
10433 pub requests: serde_json::Map<String, serde_json::Value>,
10434 }
10435
10436 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10437 #[serde(rename_all = "camelCase")]
10438 pub struct EphemeralContainersItemResources {
10439 pub limits: serde_json::Map<String, serde_json::Value>,
10440 pub requests: serde_json::Map<String, serde_json::Value>,
10441 }
10442
10443 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10444 #[serde(rename_all = "camelCase")]
10445 pub struct InitContainersItemResources {
10446 pub limits: serde_json::Map<String, serde_json::Value>,
10447 pub requests: serde_json::Map<String, serde_json::Value>,
10448 }
10449
10450 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10451 #[serde(rename_all = "camelCase")]
10452 pub struct ContainersItemSecurityContextSeLinuxOptions {
10453 pub level: String,
10454 pub role: String,
10455 pub r#type: String,
10456 pub user: String,
10457 }
10458
10459 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10460 #[serde(rename_all = "camelCase")]
10461 pub struct EphemeralContainersItemSecurityContextSeLinuxOptions {
10462 pub level: String,
10463 pub role: String,
10464 pub r#type: String,
10465 pub user: String,
10466 }
10467
10468 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10469 #[serde(rename_all = "camelCase")]
10470 pub struct InitContainersItemSecurityContextSeLinuxOptions {
10471 pub level: String,
10472 pub role: String,
10473 pub r#type: String,
10474 pub user: String,
10475 }
10476
10477 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10478 #[serde(rename_all = "camelCase")]
10479 pub struct SpecSecurityContextSeLinuxOptions {
10480 pub level: String,
10481 pub role: String,
10482 pub r#type: String,
10483 pub user: String,
10484 }
10485
10486 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10487 #[serde(rename_all = "camelCase")]
10488 pub struct ContainersItemSecurityContextSeccompProfile {
10489 pub localhost_profile: String,
10490 pub r#type: String,
10491 }
10492
10493 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10494 #[serde(rename_all = "camelCase")]
10495 pub struct EphemeralContainersItemSecurityContextSeccompProfile {
10496 pub localhost_profile: String,
10497 pub r#type: String,
10498 }
10499
10500 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10501 #[serde(rename_all = "camelCase")]
10502 pub struct InitContainersItemSecurityContextSeccompProfile {
10503 pub localhost_profile: String,
10504 pub r#type: String,
10505 }
10506
10507 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10508 #[serde(rename_all = "camelCase")]
10509 pub struct SpecSecurityContextSeccompProfile {
10510 pub localhost_profile: String,
10511 pub r#type: String,
10512 }
10513
10514 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10515 #[serde(rename_all = "camelCase")]
10516 pub struct ContainersItemEnvItemValueFromSecretKeyRef {
10517 pub key: String,
10518 pub name: String,
10519 pub optional: bool,
10520 }
10521
10522 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10523 #[serde(rename_all = "camelCase")]
10524 pub struct EphemeralContainersItemEnvItemValueFromSecretKeyRef {
10525 pub key: String,
10526 pub name: String,
10527 pub optional: bool,
10528 }
10529
10530 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10531 #[serde(rename_all = "camelCase")]
10532 pub struct InitContainersItemEnvItemValueFromSecretKeyRef {
10533 pub key: String,
10534 pub name: String,
10535 pub optional: bool,
10536 }
10537
10538 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10539 #[serde(rename_all = "camelCase")]
10540 pub struct ContainersItemEnvFromItemSecretRef {
10541 pub name: String,
10542 pub optional: bool,
10543 }
10544
10545 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10546 #[serde(rename_all = "camelCase")]
10547 pub struct EphemeralContainersItemEnvFromItemSecretRef {
10548 pub name: String,
10549 pub optional: bool,
10550 }
10551
10552 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10553 #[serde(rename_all = "camelCase")]
10554 pub struct InitContainersItemEnvFromItemSecretRef {
10555 pub name: String,
10556 pub optional: bool,
10557 }
10558
10559 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10560 #[serde(rename_all = "camelCase")]
10561 pub struct SpecSecurityContext {
10562 pub fs_group: i64,
10563 pub fs_group_change_policy: String,
10564 pub run_as_group: i64,
10565 pub run_as_non_root: bool,
10566 pub run_as_user: i64,
10567 pub se_linux_options: SpecSecurityContextSeLinuxOptions,
10568 pub seccomp_profile: SpecSecurityContextSeccompProfile,
10569 pub supplemental_groups: Vec<i64>,
10570 pub sysctls: Vec<SysctlsItem>,
10571 pub windows_options: SpecSecurityContextWindowsOptions,
10572 }
10573
10574 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10575 #[serde(rename_all = "camelCase")]
10576 pub struct ContainersItemSecurityContext {
10577 pub allow_privilege_escalation: bool,
10578 pub capabilities: ContainersItemSecurityContextCapabilities,
10579 pub privileged: bool,
10580 pub proc_mount: String,
10581 pub read_only_root_filesystem: bool,
10582 pub run_as_group: i64,
10583 pub run_as_non_root: bool,
10584 pub run_as_user: i64,
10585 pub se_linux_options: ContainersItemSecurityContextSeLinuxOptions,
10586 pub seccomp_profile: ContainersItemSecurityContextSeccompProfile,
10587 pub windows_options: ContainersItemSecurityContextWindowsOptions,
10588 }
10589
10590 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10591 #[serde(rename_all = "camelCase")]
10592 pub struct EphemeralContainersItemSecurityContext {
10593 pub allow_privilege_escalation: bool,
10594 pub capabilities: EphemeralContainersItemSecurityContextCapabilities,
10595 pub privileged: bool,
10596 pub proc_mount: String,
10597 pub read_only_root_filesystem: bool,
10598 pub run_as_group: i64,
10599 pub run_as_non_root: bool,
10600 pub run_as_user: i64,
10601 pub se_linux_options: EphemeralContainersItemSecurityContextSeLinuxOptions,
10602 pub seccomp_profile: EphemeralContainersItemSecurityContextSeccompProfile,
10603 pub windows_options: EphemeralContainersItemSecurityContextWindowsOptions,
10604 }
10605
10606 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10607 #[serde(rename_all = "camelCase")]
10608 pub struct InitContainersItemSecurityContext {
10609 pub allow_privilege_escalation: bool,
10610 pub capabilities: InitContainersItemSecurityContextCapabilities,
10611 pub privileged: bool,
10612 pub proc_mount: String,
10613 pub read_only_root_filesystem: bool,
10614 pub run_as_group: i64,
10615 pub run_as_non_root: bool,
10616 pub run_as_user: i64,
10617 pub se_linux_options: InitContainersItemSecurityContextSeLinuxOptions,
10618 pub seccomp_profile: InitContainersItemSecurityContextSeccompProfile,
10619 pub windows_options: InitContainersItemSecurityContextWindowsOptions,
10620 }
10621
10622 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10623 #[serde(rename_all = "camelCase")]
10624 pub struct SpecSelector {
10625 pub match_expressions: Vec<SpecSelectorMatchExpressionsItem>,
10626 pub match_labels: SpecSelectorMatchLabels,
10627 }
10628
10629 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10630 #[serde(rename_all = "camelCase")]
10631 pub struct TemplatesItemSelector {
10632 pub match_expressions: Vec<TemplatesItemSelectorMatchExpressionsItem>,
10633 pub match_labels: TemplatesItemSelectorMatchLabels,
10634 }
10635
10636 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10637 #[serde(rename_all = "camelCase")]
10638 pub struct SetCanaryScale {
10639 pub match_traffic_weight: bool,
10640 pub replicas: i32,
10641 pub weight: i32,
10642 }
10643
10644 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10645 #[serde(rename_all = "camelCase")]
10646 pub struct SetHeaderRoute {
10647 pub r#match: Vec<SetHeaderRouteMatchItem>,
10648 pub name: String,
10649 }
10650
10651 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10652 #[serde(rename_all = "camelCase")]
10653 pub struct SetMirrorRoute {
10654 pub r#match: Vec<SetMirrorRouteMatchItem>,
10655 pub name: String,
10656 pub percentage: i32,
10657 }
10658
10659 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10660 #[serde(rename_all = "camelCase")]
10661 pub struct Smi {
10662 pub root_service: String,
10663 pub traffic_split_name: String,
10664 }
10665
10666 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10667 #[serde(rename_all = "camelCase")]
10668 pub struct Spec {
10669 pub analysis: SpecAnalysis,
10670 pub min_ready_seconds: i32,
10671 pub paused: bool,
10672 pub progress_deadline_abort: bool,
10673 pub progress_deadline_seconds: i32,
10674 pub replicas: i32,
10675 pub restart_at: String,
10676 pub revision_history_limit: i32,
10677 pub selector: SpecSelector,
10678 pub strategy: Strategy,
10679 pub template: Template,
10680 pub workload_ref: WorkloadRef,
10681 }
10682
10683 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10684 #[serde(rename_all = "camelCase")]
10685 pub struct TemplateSpec {
10686 pub active_deadline_seconds: i64,
10687 pub affinity: Affinity,
10688 pub automount_service_account_token: bool,
10689 pub containers: Vec<ContainersItem>,
10690 pub dns_config: DnsConfig,
10691 pub dns_policy: String,
10692 pub enable_service_links: bool,
10693 pub ephemeral_containers: Vec<EphemeralContainersItem>,
10694 pub host_aliases: Vec<HostAliasesItem>,
10695 pub host_i_p_c: bool,
10696 pub host_network: bool,
10697 pub host_p_i_d: bool,
10698 pub hostname: String,
10699 pub image_pull_secrets: Vec<ImagePullSecretsItem>,
10700 pub init_containers: Vec<InitContainersItem>,
10701 pub node_name: String,
10702 pub node_selector: NodeSelector,
10703 pub os: Os,
10704 pub overhead: Overhead,
10705 pub preemption_policy: String,
10706 pub priority: i32,
10707 pub priority_class_name: String,
10708 pub readiness_gates: Vec<ReadinessGatesItem>,
10709 pub restart_policy: String,
10710 pub runtime_class_name: String,
10711 pub scheduler_name: String,
10712 pub security_context: SpecSecurityContext,
10713 pub service_account: String,
10714 pub service_account_name: String,
10715 pub set_hostname_as_f_q_d_n: bool,
10716 pub share_process_namespace: bool,
10717 pub subdomain: String,
10718 pub termination_grace_period_seconds: i64,
10719 pub tolerations: Vec<TolerationsItem>,
10720 pub topology_spread_constraints: Vec<TopologySpreadConstraintsItem>,
10721 pub volumes: Vec<serde_json::Map<String, serde_json::Value>>,
10722 }
10723
10724 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10725 #[serde(rename_all = "camelCase")]
10726 pub struct Stable {
10727 pub pod_template_hash: String,
10728 pub service_name: String,
10729 pub weight: i32,
10730 }
10731
10732 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10733 #[serde(rename_all = "camelCase")]
10734 pub struct StableMetadata {
10735 pub annotations: StableMetadataAnnotations,
10736 pub labels: StableMetadataLabels,
10737 }
10738
10739 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10740 #[serde(rename_all = "camelCase")]
10741 pub struct StableTargetGroup {
10742 pub arn: String,
10743 pub name: String,
10744 }
10745
10746 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10747 #[serde(rename_all = "camelCase")]
10748 pub struct StableVirtualNodeRef {
10749 pub name: String,
10750 }
10751
10752 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10753 #[serde(rename_all = "camelCase")]
10754 pub struct ContainersItemStartupProbe {
10755 pub exec: ContainersItemStartupProbeExec,
10756 pub failure_threshold: i32,
10757 pub grpc: ContainersItemStartupProbeGrpc,
10758 pub http_get: ContainersItemStartupProbeHttpGet,
10759 pub initial_delay_seconds: i32,
10760 pub period_seconds: i32,
10761 pub success_threshold: i32,
10762 pub tcp_socket: ContainersItemStartupProbeTcpSocket,
10763 pub termination_grace_period_seconds: i64,
10764 pub timeout_seconds: i32,
10765 }
10766
10767 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10768 #[serde(rename_all = "camelCase")]
10769 pub struct EphemeralContainersItemStartupProbe {
10770 pub exec: EphemeralContainersItemStartupProbeExec,
10771 pub failure_threshold: i32,
10772 pub grpc: EphemeralContainersItemStartupProbeGrpc,
10773 pub http_get: EphemeralContainersItemStartupProbeHttpGet,
10774 pub initial_delay_seconds: i32,
10775 pub period_seconds: i32,
10776 pub success_threshold: i32,
10777 pub tcp_socket: EphemeralContainersItemStartupProbeTcpSocket,
10778 pub termination_grace_period_seconds: i64,
10779 pub timeout_seconds: i32,
10780 }
10781
10782 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10783 #[serde(rename_all = "camelCase")]
10784 pub struct InitContainersItemStartupProbe {
10785 pub exec: InitContainersItemStartupProbeExec,
10786 pub failure_threshold: i32,
10787 pub grpc: InitContainersItemStartupProbeGrpc,
10788 pub http_get: InitContainersItemStartupProbeHttpGet,
10789 pub initial_delay_seconds: i32,
10790 pub period_seconds: i32,
10791 pub success_threshold: i32,
10792 pub tcp_socket: InitContainersItemStartupProbeTcpSocket,
10793 pub termination_grace_period_seconds: i64,
10794 pub timeout_seconds: i32,
10795 }
10796
10797 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10798 #[serde(rename_all = "camelCase")]
10799 pub struct Status {
10800 pub h_p_a_replicas: i32,
10801 pub abort: bool,
10802 pub aborted_at: String,
10803 pub alb: StatusAlb,
10804 pub available_replicas: i32,
10805 pub blue_green: StatusBlueGreen,
10806 pub canary: StatusCanary,
10807 pub collision_count: i32,
10808 pub conditions: Vec<ConditionsItem>,
10809 pub controller_pause: bool,
10810 pub current_pod_hash: String,
10811 pub current_step_hash: String,
10812 pub current_step_index: i32,
10813 pub message: String,
10814 pub observed_generation: String,
10815 pub pause_conditions: Vec<PauseConditionsItem>,
10816 pub phase: String,
10817 pub promote_full: bool,
10818 pub ready_replicas: i32,
10819 pub replicas: i32,
10820 pub restarted_at: String,
10821 pub selector: String,
10822 pub stable_r_s: String,
10823 pub updated_replicas: i32,
10824 pub workload_observed_generation: String,
10825 }
10826
10827 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10828 #[serde(rename_all = "camelCase")]
10829 pub struct StepsItem {
10830 pub analysis: StepsItemAnalysis,
10831 pub experiment: Experiment,
10832 pub pause: Pause,
10833 pub set_canary_scale: SetCanaryScale,
10834 pub set_header_route: SetHeaderRoute,
10835 pub set_mirror_route: SetMirrorRoute,
10836 pub set_weight: i32,
10837 }
10838
10839 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10840 #[serde(rename_all = "camelCase")]
10841 pub struct StickinessConfig {
10842 pub duration_seconds: i64,
10843 pub enabled: bool,
10844 }
10845
10846 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10847 #[serde(rename_all = "camelCase")]
10848 pub struct Strategy {
10849 pub blue_green: StrategyBlueGreen,
10850 pub canary: StrategyCanary,
10851 }
10852
10853 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10854 #[serde(rename_all = "camelCase")]
10855 pub struct SysctlsItem {
10856 pub name: String,
10857 pub value: String,
10858 }
10859
10860 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10861 #[serde(rename_all = "camelCase")]
10862 pub struct ContainersItemLifecyclePostStartTcpSocket {
10863 pub host: String,
10864 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10865 }
10866
10867 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10868 #[serde(rename_all = "camelCase")]
10869 pub struct ContainersItemLifecyclePreStopTcpSocket {
10870 pub host: String,
10871 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10872 }
10873
10874 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10875 #[serde(rename_all = "camelCase")]
10876 pub struct ContainersItemLivenessProbeTcpSocket {
10877 pub host: String,
10878 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10879 }
10880
10881 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10882 #[serde(rename_all = "camelCase")]
10883 pub struct ContainersItemReadinessProbeTcpSocket {
10884 pub host: String,
10885 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10886 }
10887
10888 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10889 #[serde(rename_all = "camelCase")]
10890 pub struct ContainersItemStartupProbeTcpSocket {
10891 pub host: String,
10892 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10893 }
10894
10895 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10896 #[serde(rename_all = "camelCase")]
10897 pub struct EphemeralContainersItemLifecyclePostStartTcpSocket {
10898 pub host: String,
10899 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10900 }
10901
10902 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10903 #[serde(rename_all = "camelCase")]
10904 pub struct EphemeralContainersItemLifecyclePreStopTcpSocket {
10905 pub host: String,
10906 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10907 }
10908
10909 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10910 #[serde(rename_all = "camelCase")]
10911 pub struct EphemeralContainersItemLivenessProbeTcpSocket {
10912 pub host: String,
10913 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10914 }
10915
10916 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10917 #[serde(rename_all = "camelCase")]
10918 pub struct EphemeralContainersItemReadinessProbeTcpSocket {
10919 pub host: String,
10920 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10921 }
10922
10923 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10924 #[serde(rename_all = "camelCase")]
10925 pub struct EphemeralContainersItemStartupProbeTcpSocket {
10926 pub host: String,
10927 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10928 }
10929
10930 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10931 #[serde(rename_all = "camelCase")]
10932 pub struct InitContainersItemLifecyclePostStartTcpSocket {
10933 pub host: String,
10934 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10935 }
10936
10937 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10938 #[serde(rename_all = "camelCase")]
10939 pub struct InitContainersItemLifecyclePreStopTcpSocket {
10940 pub host: String,
10941 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10942 }
10943
10944 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10945 #[serde(rename_all = "camelCase")]
10946 pub struct InitContainersItemLivenessProbeTcpSocket {
10947 pub host: String,
10948 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10949 }
10950
10951 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10952 #[serde(rename_all = "camelCase")]
10953 pub struct InitContainersItemReadinessProbeTcpSocket {
10954 pub host: String,
10955 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10956 }
10957
10958 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10959 #[serde(rename_all = "camelCase")]
10960 pub struct InitContainersItemStartupProbeTcpSocket {
10961 pub host: String,
10962 pub port: k8s_openapi::apimachinery::pkg::util::intstr::IntOrString,
10963 }
10964
10965 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10966 #[serde(rename_all = "camelCase")]
10967 pub struct Template {
10968 pub metadata: TemplateMetadata,
10969 pub spec: TemplateSpec,
10970 }
10971
10972 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10973 #[serde(rename_all = "camelCase")]
10974 pub struct PostPromotionAnalysisTemplatesItem {
10975 pub cluster_scope: bool,
10976 pub template_name: String,
10977 }
10978
10979 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10980 #[serde(rename_all = "camelCase")]
10981 pub struct PrePromotionAnalysisTemplatesItem {
10982 pub cluster_scope: bool,
10983 pub template_name: String,
10984 }
10985
10986 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10987 #[serde(rename_all = "camelCase")]
10988 pub struct CanaryAnalysisTemplatesItem {
10989 pub cluster_scope: bool,
10990 pub template_name: String,
10991 }
10992
10993 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
10994 #[serde(rename_all = "camelCase")]
10995 pub struct StepsItemAnalysisTemplatesItem {
10996 pub cluster_scope: bool,
10997 pub template_name: String,
10998 }
10999
11000 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11001 #[serde(rename_all = "camelCase")]
11002 pub struct ExperimentTemplatesItem {
11003 pub metadata: TemplatesItemMetadata,
11004 pub name: String,
11005 pub replicas: i32,
11006 pub selector: TemplatesItemSelector,
11007 pub spec_ref: String,
11008 pub weight: i32,
11009 }
11010
11011 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11012 #[serde(rename_all = "camelCase")]
11013 pub struct VirtualServiceTlsRoutesItem {
11014 pub port: i64,
11015 pub sni_hosts: Vec<String>,
11016 }
11017
11018 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11019 #[serde(rename_all = "camelCase")]
11020 pub struct VirtualServicesItemTlsRoutesItem {
11021 pub port: i64,
11022 pub sni_hosts: Vec<String>,
11023 }
11024
11025 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11026 #[serde(rename_all = "camelCase")]
11027 pub struct TolerationsItem {
11028 pub effect: String,
11029 pub key: String,
11030 pub operator: String,
11031 pub toleration_seconds: i64,
11032 pub value: String,
11033 }
11034
11035 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11036 #[serde(rename_all = "camelCase")]
11037 pub struct TopologySpreadConstraintsItem {
11038 pub label_selector: TopologySpreadConstraintsItemLabelSelector,
11039 pub max_skew: i32,
11040 pub topology_key: String,
11041 pub when_unsatisfiable: String,
11042 }
11043
11044 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11045 #[serde(rename_all = "camelCase")]
11046 pub struct Traefik {
11047 pub weighted_traefik_service_name: String,
11048 }
11049
11050 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11051 #[serde(rename_all = "camelCase")]
11052 pub struct TrafficRouting {
11053 pub alb: TrafficRoutingAlb,
11054 pub ambassador: Ambassador,
11055 pub app_mesh: AppMesh,
11056 pub istio: Istio,
11057 pub managed_routes: Vec<ManagedRoutesItem>,
11058 pub nginx: Nginx,
11059 pub smi: Smi,
11060 pub traefik: Traefik,
11061 }
11062
11063 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11064 #[serde(rename_all = "camelCase")]
11065 pub struct Value {
11066 pub exact: String,
11067 pub prefix: String,
11068 pub regex: String,
11069 }
11070
11071 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11072 #[serde(rename_all = "camelCase")]
11073 pub struct PostPromotionAnalysisArgsItemValueFrom {
11074 pub field_ref: PostPromotionAnalysisArgsItemValueFromFieldRef,
11075 pub pod_template_hash_value: String,
11076 }
11077
11078 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11079 #[serde(rename_all = "camelCase")]
11080 pub struct PrePromotionAnalysisArgsItemValueFrom {
11081 pub field_ref: PrePromotionAnalysisArgsItemValueFromFieldRef,
11082 pub pod_template_hash_value: String,
11083 }
11084
11085 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11086 #[serde(rename_all = "camelCase")]
11087 pub struct CanaryAnalysisArgsItemValueFrom {
11088 pub field_ref: CanaryAnalysisArgsItemValueFromFieldRef,
11089 pub pod_template_hash_value: String,
11090 }
11091
11092 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11093 #[serde(rename_all = "camelCase")]
11094 pub struct StepsItemAnalysisArgsItemValueFrom {
11095 pub field_ref: StepsItemAnalysisArgsItemValueFromFieldRef,
11096 pub pod_template_hash_value: String,
11097 }
11098
11099 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11100 #[serde(rename_all = "camelCase")]
11101 pub struct AnalysesItemArgsItemValueFrom {
11102 pub field_ref: AnalysesItemArgsItemValueFromFieldRef,
11103 pub pod_template_hash_value: String,
11104 }
11105
11106 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11107 #[serde(rename_all = "camelCase")]
11108 pub struct ContainersItemEnvItemValueFrom {
11109 pub config_map_key_ref: ContainersItemEnvItemValueFromConfigMapKeyRef,
11110 pub field_ref: ContainersItemEnvItemValueFromFieldRef,
11111 pub resource_field_ref: ContainersItemEnvItemValueFromResourceFieldRef,
11112 pub secret_key_ref: ContainersItemEnvItemValueFromSecretKeyRef,
11113 }
11114
11115 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11116 #[serde(rename_all = "camelCase")]
11117 pub struct EphemeralContainersItemEnvItemValueFrom {
11118 pub config_map_key_ref: EphemeralContainersItemEnvItemValueFromConfigMapKeyRef,
11119 pub field_ref: EphemeralContainersItemEnvItemValueFromFieldRef,
11120 pub resource_field_ref: EphemeralContainersItemEnvItemValueFromResourceFieldRef,
11121 pub secret_key_ref: EphemeralContainersItemEnvItemValueFromSecretKeyRef,
11122 }
11123
11124 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11125 #[serde(rename_all = "camelCase")]
11126 pub struct InitContainersItemEnvItemValueFrom {
11127 pub config_map_key_ref: InitContainersItemEnvItemValueFromConfigMapKeyRef,
11128 pub field_ref: InitContainersItemEnvItemValueFromFieldRef,
11129 pub resource_field_ref: InitContainersItemEnvItemValueFromResourceFieldRef,
11130 pub secret_key_ref: InitContainersItemEnvItemValueFromSecretKeyRef,
11131 }
11132
11133 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11134 #[serde(rename_all = "camelCase")]
11135 pub struct VirtualNodeGroup {
11136 pub canary_virtual_node_ref: CanaryVirtualNodeRef,
11137 pub stable_virtual_node_ref: StableVirtualNodeRef,
11138 }
11139
11140 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11141 #[serde(rename_all = "camelCase")]
11142 pub struct AppMeshVirtualService {
11143 pub name: String,
11144 pub routes: Vec<String>,
11145 }
11146
11147 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11148 #[serde(rename_all = "camelCase")]
11149 pub struct IstioVirtualService {
11150 pub name: String,
11151 pub routes: Vec<String>,
11152 pub tls_routes: Vec<VirtualServiceTlsRoutesItem>,
11153 }
11154
11155 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11156 #[serde(rename_all = "camelCase")]
11157 pub struct VirtualServicesItem {
11158 pub name: String,
11159 pub routes: Vec<String>,
11160 pub tls_routes: Vec<VirtualServicesItemTlsRoutesItem>,
11161 }
11162
11163 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11164 #[serde(rename_all = "camelCase")]
11165 pub struct ContainersItemVolumeDevicesItem {
11166 pub device_path: String,
11167 pub name: String,
11168 }
11169
11170 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11171 #[serde(rename_all = "camelCase")]
11172 pub struct EphemeralContainersItemVolumeDevicesItem {
11173 pub device_path: String,
11174 pub name: String,
11175 }
11176
11177 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11178 #[serde(rename_all = "camelCase")]
11179 pub struct InitContainersItemVolumeDevicesItem {
11180 pub device_path: String,
11181 pub name: String,
11182 }
11183
11184 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11185 #[serde(rename_all = "camelCase")]
11186 pub struct ContainersItemVolumeMountsItem {
11187 pub mount_path: String,
11188 pub mount_propagation: String,
11189 pub name: String,
11190 pub read_only: bool,
11191 pub sub_path: String,
11192 pub sub_path_expr: String,
11193 }
11194
11195 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11196 #[serde(rename_all = "camelCase")]
11197 pub struct EphemeralContainersItemVolumeMountsItem {
11198 pub mount_path: String,
11199 pub mount_propagation: String,
11200 pub name: String,
11201 pub read_only: bool,
11202 pub sub_path: String,
11203 pub sub_path_expr: String,
11204 }
11205
11206 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11207 #[serde(rename_all = "camelCase")]
11208 pub struct InitContainersItemVolumeMountsItem {
11209 pub mount_path: String,
11210 pub mount_propagation: String,
11211 pub name: String,
11212 pub read_only: bool,
11213 pub sub_path: String,
11214 pub sub_path_expr: String,
11215 }
11216
11217 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11218 #[serde(rename_all = "camelCase")]
11219 pub struct Weights {
11220 pub additional: Vec<AdditionalItem>,
11221 pub canary: WeightsCanary,
11222 pub stable: Stable,
11223 pub verified: bool,
11224 }
11225
11226 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11227 #[serde(rename_all = "camelCase")]
11228 pub struct ContainersItemSecurityContextWindowsOptions {
11229 pub gmsa_credential_spec: String,
11230 pub gmsa_credential_spec_name: String,
11231 pub host_process: bool,
11232 pub run_as_user_name: String,
11233 }
11234
11235 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11236 #[serde(rename_all = "camelCase")]
11237 pub struct EphemeralContainersItemSecurityContextWindowsOptions {
11238 pub gmsa_credential_spec: String,
11239 pub gmsa_credential_spec_name: String,
11240 pub host_process: bool,
11241 pub run_as_user_name: String,
11242 }
11243
11244 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11245 #[serde(rename_all = "camelCase")]
11246 pub struct InitContainersItemSecurityContextWindowsOptions {
11247 pub gmsa_credential_spec: String,
11248 pub gmsa_credential_spec_name: String,
11249 pub host_process: bool,
11250 pub run_as_user_name: String,
11251 }
11252
11253 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11254 #[serde(rename_all = "camelCase")]
11255 pub struct SpecSecurityContextWindowsOptions {
11256 pub gmsa_credential_spec: String,
11257 pub gmsa_credential_spec_name: String,
11258 pub host_process: bool,
11259 pub run_as_user_name: String,
11260 }
11261
11262 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
11263 #[serde(rename_all = "camelCase")]
11264 pub struct WorkloadRef {
11265 pub api_version: String,
11266 pub kind: String,
11267 pub name: String,
11268 }
11269 }
11270 }
11271}