1#![allow(
2 non_snake_case,
3 clippy::redundant_field_names,
4 clippy::new_without_default,
5 clippy::too_many_arguments
6)]
7
8use serde::{Deserialize, Serialize};
9use serde_json::Value;
10
11use std::collections::HashMap;
12
13use chrono::{DateTime, Utc};
14
15fn deserialize_nonoptional_vec<
16 'de,
17 D: serde::de::Deserializer<'de>,
18 T: serde::de::DeserializeOwned,
19>(
20 d: D,
21) -> Result<Vec<T>, D::Error> {
22 serde::de::Deserialize::deserialize(d).map(|x: Option<_>| x.unwrap_or_default())
23}
24
25fn deserialize_nonoptional_map<
26 'de,
27 D: serde::de::Deserializer<'de>,
28 T: serde::de::DeserializeOwned,
29>(
30 d: D,
31) -> Result<HashMap<String, T>, D::Error> {
32 serde::de::Deserialize::deserialize(d).map(|x: Option<_>| x.unwrap_or_default())
33}
34#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
35pub struct AccessMode {
36 #[serde(rename = "BlockVolume")]
37 pub block_volume: Option<TypeBlock>,
38 #[serde(rename = "MountVolume")]
39 pub mount_volume: Option<TypeMount>,
40 #[serde(rename = "Scope")]
41 pub scope: Option<String>,
42 #[serde(rename = "Sharing")]
43 pub sharing: Option<String>,
44}
45
46#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
47pub struct Address {
48 #[serde(rename = "Addr")]
49 #[serde(skip_serializing_if = "Option::is_none")]
50 pub addr: Option<String>,
51 #[serde(rename = "PrefixLength")]
52 #[serde(skip_serializing_if = "Option::is_none")]
53 pub prefix_length: Option<i64>,
54}
55
56#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
57pub struct AuthConfig {
59 #[serde(skip_serializing_if = "Option::is_none")]
60 pub auth: Option<String>,
61 #[serde(skip_serializing_if = "Option::is_none")]
62 pub email: Option<String>,
66 #[serde(skip_serializing_if = "Option::is_none")]
67 pub identitytoken: Option<String>,
70 #[serde(skip_serializing_if = "Option::is_none")]
71 pub password: Option<String>,
72 #[serde(skip_serializing_if = "Option::is_none")]
73 pub registrytoken: Option<String>,
75 #[serde(skip_serializing_if = "Option::is_none")]
76 pub serveraddress: Option<String>,
77 #[serde(skip_serializing_if = "Option::is_none")]
78 pub username: Option<String>,
79}
80
81#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
82pub struct AuthReport {
84 #[serde(rename = "IdentityToken")]
85 #[serde(skip_serializing_if = "Option::is_none")]
86 pub identity_token: Option<String>,
87 #[serde(rename = "Status")]
88 #[serde(skip_serializing_if = "Option::is_none")]
89 pub status: Option<String>,
90}
91
92#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
93pub struct AuthenticateOkBody {
95 #[serde(rename = "IdentityToken")]
96 pub identity_token: String,
98 #[serde(rename = "Status")]
99 pub status: String,
101}
102
103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
104pub struct AutoUserNsOptions {
105 #[serde(rename = "AdditionalGIDMappings")]
106 #[serde(skip_serializing_if = "Option::is_none")]
107 pub additional_gid_mappings: Option<Vec<IdMap>>,
110 #[serde(rename = "AdditionalUIDMappings")]
111 #[serde(skip_serializing_if = "Option::is_none")]
112 pub additional_uid_mappings: Option<Vec<IdMap>>,
115 #[serde(rename = "GroupFile")]
116 #[serde(skip_serializing_if = "Option::is_none")]
117 pub group_file: Option<String>,
119 #[serde(rename = "InitialSize")]
120 #[serde(skip_serializing_if = "Option::is_none")]
121 pub initial_size: Option<u32>,
124 #[serde(rename = "PasswdFile")]
125 #[serde(skip_serializing_if = "Option::is_none")]
126 pub passwd_file: Option<String>,
128 #[serde(rename = "Size")]
129 #[serde(skip_serializing_if = "Option::is_none")]
130 pub size: Option<u32>,
134}
135
136pub type Availability = String;
137
138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
139pub struct BindOptions {
140 #[serde(rename = "CreateMountpoint")]
141 #[serde(skip_serializing_if = "Option::is_none")]
142 pub create_mountpoint: Option<bool>,
143 #[serde(rename = "NonRecursive")]
144 #[serde(skip_serializing_if = "Option::is_none")]
145 pub non_recursive: Option<bool>,
146 #[serde(rename = "Propagation")]
147 pub propagation: Option<String>,
148}
149
150#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
151pub struct CapacityRange {
154 #[serde(rename = "LimitBytes")]
155 #[serde(skip_serializing_if = "Option::is_none")]
156 pub limit_bytes: Option<i64>,
159 #[serde(rename = "RequiredBytes")]
160 #[serde(skip_serializing_if = "Option::is_none")]
161 pub required_bytes: Option<i64>,
164}
165
166pub type CgroupSpec = String;
167
168pub type CgroupnsMode = String;
170
171pub type ClusterOptions = Value;
172
173#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
174pub struct ClusterVolume {
177 #[serde(rename = "CreatedAt")]
178 #[serde(skip_serializing_if = "Option::is_none")]
179 pub created_at: Option<DateTime<Utc>>,
180 #[serde(rename = "ID")]
181 #[serde(skip_serializing_if = "Option::is_none")]
182 pub id: Option<String>,
186 #[serde(rename = "Info")]
187 pub info: Option<Info>,
188 #[serde(rename = "PublishStatus")]
189 #[serde(skip_serializing_if = "Option::is_none")]
190 pub publish_status: Option<Vec<PublishStatus>>,
193 #[serde(rename = "Spec")]
194 pub spec: Option<ClusterVolumeSpec>,
195 #[serde(rename = "UpdatedAt")]
196 #[serde(skip_serializing_if = "Option::is_none")]
197 pub updated_at: Option<DateTime<Utc>>,
198 #[serde(rename = "Version")]
199 pub version: Option<Version>,
200}
201
202#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
203pub struct ClusterVolumeSpec {
204 #[serde(rename = "AccessMode")]
205 pub access_mode: Option<AccessMode>,
206 #[serde(rename = "AccessibilityRequirements")]
207 pub accessibility_requirements: Option<TopologyRequirement>,
208 #[serde(rename = "Availability")]
209 pub availability: Option<String>,
210 #[serde(rename = "CapacityRange")]
211 pub capacity_range: Option<CapacityRange>,
212 #[serde(rename = "Group")]
213 #[serde(skip_serializing_if = "Option::is_none")]
214 pub group: Option<String>,
221 #[serde(rename = "Secrets")]
222 #[serde(skip_serializing_if = "Option::is_none")]
223 pub secrets: Option<Vec<Secret>>,
226}
227
228#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
229pub struct ComponentVersion {
230 #[serde(rename = "ApiVersion")]
231 #[serde(skip_serializing_if = "Option::is_none")]
232 pub api_version: Option<String>,
233 #[serde(rename = "Arch")]
234 #[serde(skip_serializing_if = "Option::is_none")]
235 pub arch: Option<String>,
236 #[serde(rename = "BuildTime")]
237 #[serde(skip_serializing_if = "Option::is_none")]
238 pub build_time: Option<String>,
239 #[serde(rename = "Components")]
240 #[serde(skip_serializing_if = "Option::is_none")]
241 pub components: Option<Vec<ComponentVersion>>,
242 #[serde(rename = "Experimental")]
243 #[serde(skip_serializing_if = "Option::is_none")]
244 pub experimental: Option<bool>,
245 #[serde(rename = "GitCommit")]
246 #[serde(skip_serializing_if = "Option::is_none")]
247 pub git_commit: Option<String>,
248 #[serde(rename = "GoVersion")]
249 #[serde(skip_serializing_if = "Option::is_none")]
250 pub go_version: Option<String>,
251 #[serde(rename = "KernelVersion")]
252 #[serde(skip_serializing_if = "Option::is_none")]
253 pub kernel_version: Option<String>,
254 #[serde(rename = "MinAPIVersion")]
255 #[serde(skip_serializing_if = "Option::is_none")]
256 pub min_api_version: Option<String>,
257 #[serde(rename = "Os")]
258 #[serde(skip_serializing_if = "Option::is_none")]
259 pub os: Option<String>,
260 #[serde(rename = "Platform")]
261 #[serde(skip_serializing_if = "Option::is_none")]
262 pub platform: Option<Value>,
263 #[serde(rename = "Version")]
264 #[serde(skip_serializing_if = "Option::is_none")]
265 pub version: Option<String>,
266}
267
268#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
269pub struct Config {
275 #[serde(rename = "ArgsEscaped")]
276 #[serde(skip_serializing_if = "Option::is_none")]
277 pub args_escaped: Option<bool>,
278 #[serde(rename = "AttachStderr")]
279 #[serde(skip_serializing_if = "Option::is_none")]
280 pub attach_stderr: Option<bool>,
281 #[serde(rename = "AttachStdin")]
282 #[serde(skip_serializing_if = "Option::is_none")]
283 pub attach_stdin: Option<bool>,
284 #[serde(rename = "AttachStdout")]
285 #[serde(skip_serializing_if = "Option::is_none")]
286 pub attach_stdout: Option<bool>,
287 #[serde(rename = "Cmd")]
288 pub cmd: Option<StrSlice>,
289 #[serde(rename = "Domainname")]
290 #[serde(skip_serializing_if = "Option::is_none")]
291 pub domainname: Option<String>,
292 #[serde(rename = "Entrypoint")]
293 pub entrypoint: Option<StrSlice>,
294 #[serde(rename = "Env")]
295 #[serde(skip_serializing_if = "Option::is_none")]
296 pub env: Option<Vec<String>>,
297 #[serde(rename = "ExposedPorts")]
298 pub exposed_ports: Option<PortSet>,
299 #[serde(rename = "Healthcheck")]
300 pub healthcheck: Option<HealthConfig>,
301 #[serde(rename = "Hostname")]
302 #[serde(skip_serializing_if = "Option::is_none")]
303 pub hostname: Option<String>,
304 #[serde(rename = "Image")]
305 #[serde(skip_serializing_if = "Option::is_none")]
306 pub image: Option<String>,
307 #[serde(rename = "Labels")]
308 #[serde(skip_serializing_if = "Option::is_none")]
309 pub labels: Option<HashMap<String, String>>,
310 #[serde(rename = "MacAddress")]
311 #[serde(skip_serializing_if = "Option::is_none")]
312 pub mac_address: Option<String>,
313 #[serde(rename = "NetworkDisabled")]
314 #[serde(skip_serializing_if = "Option::is_none")]
315 pub network_disabled: Option<bool>,
316 #[serde(rename = "OnBuild")]
317 #[serde(skip_serializing_if = "Option::is_none")]
318 pub on_build: Option<Vec<String>>,
319 #[serde(rename = "OpenStdin")]
320 #[serde(skip_serializing_if = "Option::is_none")]
321 pub open_stdin: Option<bool>,
322 #[serde(rename = "Shell")]
323 pub shell: Option<StrSlice>,
324 #[serde(rename = "StdinOnce")]
325 #[serde(skip_serializing_if = "Option::is_none")]
326 pub stdin_once: Option<bool>,
327 #[serde(rename = "StopSignal")]
328 #[serde(skip_serializing_if = "Option::is_none")]
329 pub stop_signal: Option<String>,
330 #[serde(rename = "StopTimeout")]
331 #[serde(skip_serializing_if = "Option::is_none")]
332 pub stop_timeout: Option<i64>,
333 #[serde(rename = "Tty")]
334 #[serde(skip_serializing_if = "Option::is_none")]
335 pub tty: Option<bool>,
336 #[serde(rename = "User")]
337 #[serde(skip_serializing_if = "Option::is_none")]
338 pub user: Option<String>,
339 #[serde(rename = "Volumes")]
340 #[serde(skip_serializing_if = "Option::is_none")]
341 pub volumes: Option<HashMap<String, Value>>,
342 #[serde(rename = "WorkingDir")]
343 #[serde(skip_serializing_if = "Option::is_none")]
344 pub working_dir: Option<String>,
345}
346
347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
348pub struct ConfigReference {
350 #[serde(rename = "Network")]
351 #[serde(skip_serializing_if = "Option::is_none")]
352 pub network: Option<String>,
353}
354
355pub type Consistency = String;
356
357#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
358pub struct Container {
359 #[serde(rename = "AdjustCPUShares")]
360 #[serde(skip_serializing_if = "Option::is_none")]
361 pub adjust_cpu_shares: Option<bool>,
362 #[serde(rename = "Command")]
363 #[serde(skip_serializing_if = "Option::is_none")]
364 pub command: Option<String>,
365 #[serde(rename = "Config")]
366 pub config: Option<Config>,
367 #[serde(rename = "Created")]
368 #[serde(skip_serializing_if = "Option::is_none")]
369 pub created: Option<i64>,
370 #[serde(rename = "HostConfig")]
371 pub host_config: Option<HostConfig>,
372 #[serde(rename = "Id")]
373 #[serde(skip_serializing_if = "Option::is_none")]
374 pub id: Option<String>,
375 #[serde(rename = "Image")]
376 #[serde(skip_serializing_if = "Option::is_none")]
377 pub image: Option<String>,
378 #[serde(rename = "ImageID")]
379 #[serde(skip_serializing_if = "Option::is_none")]
380 pub image_id: Option<String>,
381 #[serde(rename = "Labels")]
382 #[serde(skip_serializing_if = "Option::is_none")]
383 pub labels: Option<HashMap<String, String>>,
384 #[serde(rename = "Mounts")]
385 #[serde(skip_serializing_if = "Option::is_none")]
386 pub mounts: Option<Vec<MountPoint>>,
387 #[serde(rename = "Name")]
388 #[serde(skip_serializing_if = "Option::is_none")]
389 pub name: Option<String>,
390 #[serde(rename = "Names")]
391 #[serde(skip_serializing_if = "Option::is_none")]
392 pub names: Option<Vec<String>>,
393 #[serde(rename = "NetworkSettings")]
394 pub network_settings: Option<SummaryNetworkSettings>,
395 #[serde(rename = "NetworkingConfig")]
396 pub networking_config: Option<NetworkingConfig>,
397 #[serde(rename = "Platform")]
398 pub platform: Option<Platform>,
399 #[serde(rename = "Ports")]
400 #[serde(skip_serializing_if = "Option::is_none")]
401 pub ports: Option<Vec<Port>>,
402 #[serde(rename = "SizeRootFs")]
403 #[serde(skip_serializing_if = "Option::is_none")]
404 pub size_root_fs: Option<i64>,
405 #[serde(rename = "SizeRw")]
406 #[serde(skip_serializing_if = "Option::is_none")]
407 pub size_rw: Option<i64>,
408 #[serde(rename = "State")]
409 #[serde(skip_serializing_if = "Option::is_none")]
410 pub state: Option<String>,
411 #[serde(rename = "Status")]
412 #[serde(skip_serializing_if = "Option::is_none")]
413 pub status: Option<String>,
414}
415
416pub type ContainerArchive200Response = Vec<u8>;
418
419pub type ContainerArchiveLibpod200Response = Vec<u8>;
421
422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
423pub struct ContainerBasicConfig {
424 #[serde(skip_serializing_if = "Option::is_none")]
425 pub annotations: Option<HashMap<String, String>>,
429 #[serde(skip_serializing_if = "Option::is_none")]
430 pub command: Option<Vec<String>>,
435 #[serde(skip_serializing_if = "Option::is_none")]
436 pub conmon_pid_file: Option<String>,
441 #[serde(rename = "containerCreateCommand")]
442 #[serde(skip_serializing_if = "Option::is_none")]
443 pub container_create_command: Option<Vec<String>>,
450 #[serde(rename = "dependencyContainers")]
451 #[serde(skip_serializing_if = "Option::is_none")]
452 pub dependency_containers: Option<Vec<String>>,
457 #[serde(skip_serializing_if = "Option::is_none")]
458 pub entrypoint: Option<Vec<String>>,
463 #[serde(skip_serializing_if = "Option::is_none")]
464 pub env: Option<HashMap<String, String>>,
468 #[serde(skip_serializing_if = "Option::is_none")]
469 pub env_host: Option<bool>,
472 #[serde(skip_serializing_if = "Option::is_none")]
473 pub envmerge: Option<Vec<String>>,
476 #[serde(skip_serializing_if = "Option::is_none")]
477 pub group_entry: Option<String>,
479 #[serde(skip_serializing_if = "Option::is_none")]
480 pub hostname: Option<String>,
486 #[serde(skip_serializing_if = "Option::is_none")]
487 pub hostusers: Option<Vec<String>>,
490 #[serde(skip_serializing_if = "Option::is_none")]
491 pub httpproxy: Option<bool>,
495 #[serde(skip_serializing_if = "Option::is_none")]
496 pub image_arch: Option<String>,
498 #[serde(skip_serializing_if = "Option::is_none")]
499 pub image_os: Option<String>,
501 #[serde(skip_serializing_if = "Option::is_none")]
502 pub image_variant: Option<String>,
504 #[serde(skip_serializing_if = "Option::is_none")]
505 pub init_container_type: Option<String>,
508 #[serde(skip_serializing_if = "Option::is_none")]
509 pub labels: Option<HashMap<String, String>>,
513 pub log_configuration: Option<LogConfigLibpod>,
514 #[serde(skip_serializing_if = "Option::is_none")]
515 pub manage_password: Option<bool>,
517 #[serde(skip_serializing_if = "Option::is_none")]
518 pub name: Option<String>,
522 #[serde(skip_serializing_if = "Option::is_none")]
523 pub namespace: Option<String>,
526 #[serde(skip_serializing_if = "Option::is_none")]
527 pub oci_runtime: Option<String>,
532 #[serde(skip_serializing_if = "Option::is_none")]
533 pub passwd_entry: Option<String>,
535 pub personality: Option<LinuxPersonality>,
536 pub pidns: Option<Namespace>,
537 #[serde(skip_serializing_if = "Option::is_none")]
538 pub pod: Option<String>,
541 #[serde(skip_serializing_if = "Option::is_none")]
542 pub raw_image_name: Option<String>,
545 #[serde(skip_serializing_if = "Option::is_none")]
546 pub remove: Option<bool>,
549 #[serde(skip_serializing_if = "Option::is_none")]
550 pub restart_policy: Option<String>,
555 #[serde(skip_serializing_if = "Option::is_none")]
556 pub restart_tries: Option<u64>,
561 #[serde(rename = "sdnotifyMode")]
562 #[serde(skip_serializing_if = "Option::is_none")]
563 pub sdnotify_mode: Option<String>,
568 #[serde(skip_serializing_if = "Option::is_none")]
569 pub secret_env: Option<HashMap<String, String>>,
572 #[serde(skip_serializing_if = "Option::is_none")]
573 pub stdin: Option<bool>,
575 pub stop_signal: Option<i64>,
576 #[serde(skip_serializing_if = "Option::is_none")]
577 pub stop_timeout: Option<u64>,
584 #[serde(skip_serializing_if = "Option::is_none")]
585 pub sysctl: Option<HashMap<String, String>>,
587 #[serde(skip_serializing_if = "Option::is_none")]
588 pub systemd: Option<String>,
599 #[serde(skip_serializing_if = "Option::is_none")]
600 pub terminal: Option<bool>,
603 #[serde(skip_serializing_if = "Option::is_none")]
604 pub timeout: Option<u64>,
609 #[serde(skip_serializing_if = "Option::is_none")]
610 pub timezone: Option<String>,
614 #[serde(skip_serializing_if = "Option::is_none")]
615 pub unsetenv: Option<Vec<String>>,
618 #[serde(skip_serializing_if = "Option::is_none")]
619 pub unsetenvall: Option<bool>,
623 pub utsns: Option<Namespace>,
624}
625
626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
627pub struct ContainerCgroupConfig {
630 #[serde(skip_serializing_if = "Option::is_none")]
631 pub cgroup_parent: Option<String>,
635 pub cgroupns: Option<Namespace>,
636 #[serde(skip_serializing_if = "Option::is_none")]
637 pub cgroups_mode: Option<String>,
640}
641
642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
643pub struct ContainerChangeResponseItem {
645 #[serde(rename = "Kind")]
646 pub kind: u8,
648 #[serde(rename = "Path")]
649 pub path: String,
651}
652
653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
654pub struct ContainerCreateResponse {
656 #[serde(rename = "Id")]
657 pub id: String,
659 #[serde(rename = "Warnings")]
660 #[serde(default)]
661 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
662 pub warnings: Vec<String>,
664}
665
666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
667pub struct ContainerExecControlParam {
668 #[serde(rename = "AttachStderr")]
669 #[serde(skip_serializing_if = "Option::is_none")]
670 pub attach_stderr: Option<bool>,
672 #[serde(rename = "AttachStdin")]
673 #[serde(skip_serializing_if = "Option::is_none")]
674 pub attach_stdin: Option<bool>,
676 #[serde(rename = "AttachStdout")]
677 #[serde(skip_serializing_if = "Option::is_none")]
678 pub attach_stdout: Option<bool>,
680 #[serde(rename = "Cmd")]
681 #[serde(skip_serializing_if = "Option::is_none")]
682 pub cmd: Option<Vec<String>>,
684 #[serde(rename = "DetachKeys")]
685 #[serde(skip_serializing_if = "Option::is_none")]
686 pub detach_keys: Option<String>,
688 #[serde(rename = "Env")]
689 #[serde(skip_serializing_if = "Option::is_none")]
690 pub env: Option<Vec<String>>,
692 #[serde(rename = "Privileged")]
693 #[serde(skip_serializing_if = "Option::is_none")]
694 pub privileged: Option<bool>,
696 #[serde(rename = "Tty")]
697 #[serde(skip_serializing_if = "Option::is_none")]
698 pub tty: Option<bool>,
700 #[serde(rename = "User")]
701 #[serde(skip_serializing_if = "Option::is_none")]
702 pub user: Option<String>,
704 #[serde(rename = "WorkingDir")]
705 #[serde(skip_serializing_if = "Option::is_none")]
706 pub working_dir: Option<String>,
708}
709
710#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
711pub struct ContainerExecLibpodControlParam {
712 #[serde(rename = "AttachStderr")]
713 #[serde(skip_serializing_if = "Option::is_none")]
714 pub attach_stderr: Option<bool>,
716 #[serde(rename = "AttachStdin")]
717 #[serde(skip_serializing_if = "Option::is_none")]
718 pub attach_stdin: Option<bool>,
720 #[serde(rename = "AttachStdout")]
721 #[serde(skip_serializing_if = "Option::is_none")]
722 pub attach_stdout: Option<bool>,
724 #[serde(rename = "Cmd")]
725 #[serde(skip_serializing_if = "Option::is_none")]
726 pub cmd: Option<Vec<String>>,
728 #[serde(rename = "DetachKeys")]
729 #[serde(skip_serializing_if = "Option::is_none")]
730 pub detach_keys: Option<String>,
732 #[serde(rename = "Env")]
733 #[serde(skip_serializing_if = "Option::is_none")]
734 pub env: Option<Vec<String>>,
736 #[serde(rename = "Privileged")]
737 #[serde(skip_serializing_if = "Option::is_none")]
738 pub privileged: Option<bool>,
740 #[serde(rename = "Tty")]
741 #[serde(skip_serializing_if = "Option::is_none")]
742 pub tty: Option<bool>,
744 #[serde(rename = "User")]
745 #[serde(skip_serializing_if = "Option::is_none")]
746 pub user: Option<String>,
748 #[serde(rename = "WorkingDir")]
749 #[serde(skip_serializing_if = "Option::is_none")]
750 pub working_dir: Option<String>,
752}
753
754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
755pub struct ContainerHealthCheckConfig {
758 pub health_check_on_failure_action: Option<i64>,
759 pub healthconfig: Option<Schema2HealthConfig>,
760 #[serde(rename = "startupHealthConfig")]
761 pub startup_health_config: Option<StartupHealthCheck>,
762}
763
764#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
765pub struct ContainerJson {
767 #[serde(rename = "AppArmorProfile")]
768 #[serde(skip_serializing_if = "Option::is_none")]
769 pub app_armor_profile: Option<String>,
770 #[serde(rename = "Args")]
771 #[serde(skip_serializing_if = "Option::is_none")]
772 pub args: Option<Vec<String>>,
773 #[serde(rename = "Config")]
774 pub config: Option<Config>,
775 #[serde(rename = "Created")]
776 #[serde(skip_serializing_if = "Option::is_none")]
777 pub created: Option<String>,
778 #[serde(rename = "Driver")]
779 #[serde(skip_serializing_if = "Option::is_none")]
780 pub driver: Option<String>,
781 #[serde(rename = "ExecIDs")]
782 #[serde(skip_serializing_if = "Option::is_none")]
783 pub exec_i_ds: Option<Vec<String>>,
784 #[serde(rename = "GraphDriver")]
785 pub graph_driver: Option<GraphDriverData>,
786 #[serde(rename = "HostConfig")]
787 pub host_config: Option<HostConfig>,
788 #[serde(rename = "HostnamePath")]
789 #[serde(skip_serializing_if = "Option::is_none")]
790 pub hostname_path: Option<String>,
791 #[serde(rename = "HostsPath")]
792 #[serde(skip_serializing_if = "Option::is_none")]
793 pub hosts_path: Option<String>,
794 #[serde(rename = "Id")]
795 #[serde(skip_serializing_if = "Option::is_none")]
796 pub id: Option<String>,
797 #[serde(rename = "Image")]
798 #[serde(skip_serializing_if = "Option::is_none")]
799 pub image: Option<String>,
800 #[serde(rename = "LogPath")]
801 #[serde(skip_serializing_if = "Option::is_none")]
802 pub log_path: Option<String>,
803 #[serde(rename = "MountLabel")]
804 #[serde(skip_serializing_if = "Option::is_none")]
805 pub mount_label: Option<String>,
806 #[serde(rename = "Mounts")]
807 #[serde(skip_serializing_if = "Option::is_none")]
808 pub mounts: Option<Vec<MountPoint>>,
809 #[serde(rename = "Name")]
810 #[serde(skip_serializing_if = "Option::is_none")]
811 pub name: Option<String>,
812 #[serde(rename = "NetworkSettings")]
813 pub network_settings: Option<NetworkSettings>,
814 #[serde(rename = "Node")]
815 pub node: Option<ContainerNode>,
816 #[serde(rename = "Path")]
817 #[serde(skip_serializing_if = "Option::is_none")]
818 pub path: Option<String>,
819 #[serde(rename = "Platform")]
820 #[serde(skip_serializing_if = "Option::is_none")]
821 pub platform: Option<String>,
822 #[serde(rename = "ProcessLabel")]
823 #[serde(skip_serializing_if = "Option::is_none")]
824 pub process_label: Option<String>,
825 #[serde(rename = "ResolvConfPath")]
826 #[serde(skip_serializing_if = "Option::is_none")]
827 pub resolv_conf_path: Option<String>,
828 #[serde(rename = "RestartCount")]
829 #[serde(skip_serializing_if = "Option::is_none")]
830 pub restart_count: Option<i64>,
831 #[serde(rename = "SizeRootFs")]
832 #[serde(skip_serializing_if = "Option::is_none")]
833 pub size_root_fs: Option<i64>,
834 #[serde(rename = "SizeRw")]
835 #[serde(skip_serializing_if = "Option::is_none")]
836 pub size_rw: Option<i64>,
837 #[serde(rename = "State")]
838 pub state: Option<ContainerState>,
839}
840
841pub type ContainerMountLibpod200Response = String;
843
844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
845pub struct ContainerNetworkConfig {
848 #[serde(rename = "Networks")]
849 #[serde(skip_serializing_if = "Option::is_none")]
850 pub networks: Option<HashMap<String, PerNetworkOptions>>,
857 #[serde(skip_serializing_if = "Option::is_none")]
858 pub cni_networks: Option<Vec<String>>,
866 #[serde(skip_serializing_if = "Option::is_none")]
867 pub dns_option: Option<Vec<String>>,
873 #[serde(skip_serializing_if = "Option::is_none")]
874 pub dns_search: Option<Vec<String>>,
880 #[serde(skip_serializing_if = "Option::is_none")]
881 pub dns_server: Option<Vec<String>>,
887 #[serde(skip_serializing_if = "Option::is_none")]
888 pub expose: Option<Value>,
898 #[serde(skip_serializing_if = "Option::is_none")]
899 pub hostadd: Option<Vec<String>>,
904 pub netns: Option<Namespace>,
905 #[serde(skip_serializing_if = "Option::is_none")]
906 pub network_options: Option<HashMap<String, Vec<String>>>,
909 #[serde(skip_serializing_if = "Option::is_none")]
910 pub portmappings: Option<Vec<PortMapping>>,
914 #[serde(skip_serializing_if = "Option::is_none")]
915 pub publish_image_ports: Option<bool>,
921 #[serde(skip_serializing_if = "Option::is_none")]
922 pub use_image_hosts: Option<bool>,
932 #[serde(skip_serializing_if = "Option::is_none")]
933 pub use_image_resolve_conf: Option<bool>,
937}
938
939#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
940pub struct ContainerNode {
943 #[serde(rename = "Addr")]
944 #[serde(skip_serializing_if = "Option::is_none")]
945 pub addr: Option<String>,
946 #[serde(rename = "Cpus")]
947 #[serde(skip_serializing_if = "Option::is_none")]
948 pub cpus: Option<i64>,
949 #[serde(rename = "ID")]
950 #[serde(skip_serializing_if = "Option::is_none")]
951 pub id: Option<String>,
952 #[serde(rename = "IP")]
953 #[serde(skip_serializing_if = "Option::is_none")]
954 pub ip: Option<String>,
955 #[serde(rename = "Labels")]
956 #[serde(skip_serializing_if = "Option::is_none")]
957 pub labels: Option<HashMap<String, String>>,
958 #[serde(rename = "Memory")]
959 #[serde(skip_serializing_if = "Option::is_none")]
960 pub memory: Option<i64>,
961 #[serde(rename = "Name")]
962 #[serde(skip_serializing_if = "Option::is_none")]
963 pub name: Option<String>,
964}
965
966#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
967pub struct ContainerResourceConfig {
968 #[serde(skip_serializing_if = "Option::is_none")]
969 pub cpu_period: Option<u64>,
971 #[serde(skip_serializing_if = "Option::is_none")]
972 pub cpu_quota: Option<i64>,
974 #[serde(skip_serializing_if = "Option::is_none")]
975 pub oom_score_adj: Option<i64>,
979 #[serde(skip_serializing_if = "Option::is_none")]
980 pub r_limits: Option<Vec<PosixRlimit>>,
983 pub resource_limits: Option<LinuxResources>,
984 #[serde(rename = "throttleReadBpsDevice")]
985 #[serde(skip_serializing_if = "Option::is_none")]
986 pub throttle_read_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
988 #[serde(rename = "throttleReadIOPSDevice")]
989 #[serde(skip_serializing_if = "Option::is_none")]
990 pub throttle_read_iops_device: Option<HashMap<String, LinuxThrottleDevice>>,
992 #[serde(rename = "throttleWriteBpsDevice")]
993 #[serde(skip_serializing_if = "Option::is_none")]
994 pub throttle_write_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
996 #[serde(rename = "throttleWriteIOPSDevice")]
997 #[serde(skip_serializing_if = "Option::is_none")]
998 pub throttle_write_iops_device: Option<HashMap<String, LinuxThrottleDevice>>,
1000 #[serde(skip_serializing_if = "Option::is_none")]
1001 pub unified: Option<HashMap<String, String>>,
1005 #[serde(rename = "weightDevice")]
1006 #[serde(skip_serializing_if = "Option::is_none")]
1007 pub weight_device: Option<HashMap<String, LinuxWeightDevice>>,
1009}
1010
1011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1012pub struct ContainerSecurityConfig {
1015 #[serde(skip_serializing_if = "Option::is_none")]
1016 pub apparmor_profile: Option<String>,
1020 #[serde(skip_serializing_if = "Option::is_none")]
1021 pub cap_add: Option<Vec<String>>,
1025 #[serde(skip_serializing_if = "Option::is_none")]
1026 pub cap_drop: Option<Vec<String>>,
1030 #[serde(skip_serializing_if = "Option::is_none")]
1031 pub groups: Option<Vec<String>>,
1035 pub idmappings: Option<IdMappingOptions>,
1036 #[serde(skip_serializing_if = "Option::is_none")]
1037 pub label_nested: Option<bool>,
1040 #[serde(skip_serializing_if = "Option::is_none")]
1041 pub mask: Option<Vec<String>>,
1045 #[serde(skip_serializing_if = "Option::is_none")]
1046 pub no_new_privileges: Option<bool>,
1050 #[serde(skip_serializing_if = "Option::is_none")]
1051 pub privileged: Option<bool>,
1060 #[serde(skip_serializing_if = "Option::is_none")]
1061 pub procfs_opts: Option<Vec<String>>,
1063 #[serde(skip_serializing_if = "Option::is_none")]
1064 pub read_only_filesystem: Option<bool>,
1067 #[serde(skip_serializing_if = "Option::is_none")]
1068 pub read_write_tmpfs: Option<bool>,
1071 #[serde(skip_serializing_if = "Option::is_none")]
1072 pub seccomp_policy: Option<String>,
1075 #[serde(skip_serializing_if = "Option::is_none")]
1076 pub seccomp_profile_path: Option<String>,
1081 #[serde(skip_serializing_if = "Option::is_none")]
1082 pub selinux_opts: Option<Vec<String>>,
1087 #[serde(skip_serializing_if = "Option::is_none")]
1088 pub umask: Option<String>,
1090 #[serde(skip_serializing_if = "Option::is_none")]
1091 pub unmask: Option<Vec<String>>,
1094 #[serde(skip_serializing_if = "Option::is_none")]
1095 pub user: Option<String>,
1101 pub userns: Option<Namespace>,
1102}
1103
1104pub type ContainerShowMountedLibpod200Response = HashMap<String, String>;
1106
1107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1108pub struct ContainerSize {
1111 #[serde(rename = "rootFsSize")]
1112 #[serde(skip_serializing_if = "Option::is_none")]
1113 pub root_fs_size: Option<i64>,
1114 #[serde(rename = "rwSize")]
1115 #[serde(skip_serializing_if = "Option::is_none")]
1116 pub rw_size: Option<i64>,
1117}
1118
1119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1120pub struct ContainerState {
1123 #[serde(rename = "Dead")]
1124 #[serde(skip_serializing_if = "Option::is_none")]
1125 pub dead: Option<bool>,
1126 #[serde(rename = "Error")]
1127 #[serde(skip_serializing_if = "Option::is_none")]
1128 pub error: Option<String>,
1129 #[serde(rename = "ExitCode")]
1130 #[serde(skip_serializing_if = "Option::is_none")]
1131 pub exit_code: Option<i64>,
1132 #[serde(rename = "FinishedAt")]
1133 #[serde(skip_serializing_if = "Option::is_none")]
1134 pub finished_at: Option<String>,
1135 #[serde(rename = "Health")]
1136 pub health: Option<Health>,
1137 #[serde(rename = "OOMKilled")]
1138 #[serde(skip_serializing_if = "Option::is_none")]
1139 pub oom_killed: Option<bool>,
1140 #[serde(rename = "Paused")]
1141 #[serde(skip_serializing_if = "Option::is_none")]
1142 pub paused: Option<bool>,
1143 #[serde(rename = "Pid")]
1144 #[serde(skip_serializing_if = "Option::is_none")]
1145 pub pid: Option<i64>,
1146 #[serde(rename = "Restarting")]
1147 #[serde(skip_serializing_if = "Option::is_none")]
1148 pub restarting: Option<bool>,
1149 #[serde(rename = "Running")]
1150 #[serde(skip_serializing_if = "Option::is_none")]
1151 pub running: Option<bool>,
1152 #[serde(rename = "StartedAt")]
1153 #[serde(skip_serializing_if = "Option::is_none")]
1154 pub started_at: Option<String>,
1155 #[serde(rename = "Status")]
1156 #[serde(skip_serializing_if = "Option::is_none")]
1157 pub status: Option<String>,
1158}
1159
1160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1161pub struct ContainerStats {
1163 #[serde(rename = "AvgCPU")]
1164 #[serde(skip_serializing_if = "Option::is_none")]
1165 pub avg_cpu: Option<f64>,
1166 #[serde(rename = "BlockInput")]
1167 #[serde(skip_serializing_if = "Option::is_none")]
1168 pub block_input: Option<u64>,
1169 #[serde(rename = "BlockOutput")]
1170 #[serde(skip_serializing_if = "Option::is_none")]
1171 pub block_output: Option<u64>,
1172 #[serde(rename = "CPU")]
1173 #[serde(skip_serializing_if = "Option::is_none")]
1174 pub cpu: Option<f64>,
1175 #[serde(rename = "CPUNano")]
1176 #[serde(skip_serializing_if = "Option::is_none")]
1177 pub cpu_nano: Option<u64>,
1178 #[serde(rename = "CPUSystemNano")]
1179 #[serde(skip_serializing_if = "Option::is_none")]
1180 pub cpu_system_nano: Option<u64>,
1181 #[serde(rename = "ContainerID")]
1182 #[serde(skip_serializing_if = "Option::is_none")]
1183 pub container_id: Option<String>,
1184 #[serde(rename = "Duration")]
1185 #[serde(skip_serializing_if = "Option::is_none")]
1186 pub duration: Option<u64>,
1187 #[serde(rename = "MemLimit")]
1188 #[serde(skip_serializing_if = "Option::is_none")]
1189 pub mem_limit: Option<u64>,
1190 #[serde(rename = "MemPerc")]
1191 #[serde(skip_serializing_if = "Option::is_none")]
1192 pub mem_perc: Option<f64>,
1193 #[serde(rename = "MemUsage")]
1194 #[serde(skip_serializing_if = "Option::is_none")]
1195 pub mem_usage: Option<u64>,
1196 #[serde(rename = "Name")]
1197 #[serde(skip_serializing_if = "Option::is_none")]
1198 pub name: Option<String>,
1199 #[serde(rename = "NetInput")]
1200 #[serde(skip_serializing_if = "Option::is_none")]
1201 pub net_input: Option<u64>,
1202 #[serde(rename = "NetOutput")]
1203 #[serde(skip_serializing_if = "Option::is_none")]
1204 pub net_output: Option<u64>,
1205 #[serde(rename = "PIDs")]
1206 #[serde(skip_serializing_if = "Option::is_none")]
1207 pub pi_ds: Option<u64>,
1208 #[serde(rename = "PerCPU")]
1209 #[serde(skip_serializing_if = "Option::is_none")]
1210 pub per_cpu: Option<Vec<u64>>,
1211 #[serde(rename = "SystemNano")]
1212 #[serde(skip_serializing_if = "Option::is_none")]
1213 pub system_nano: Option<u64>,
1214 #[serde(rename = "UpTime")]
1215 pub up_time: Option<i64>,
1216}
1217
1218pub type ContainerStats200Response = Value;
1220
1221#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1222pub struct ContainerStorageConfig {
1225 #[serde(skip_serializing_if = "Option::is_none")]
1226 pub chroot_directories: Option<Vec<String>>,
1230 #[serde(skip_serializing_if = "Option::is_none")]
1231 pub create_working_dir: Option<bool>,
1235 #[serde(skip_serializing_if = "Option::is_none")]
1236 pub device_cgroup_rule: Option<Vec<LinuxDeviceCgroup>>,
1239 #[serde(skip_serializing_if = "Option::is_none")]
1240 pub devices: Option<Vec<LinuxDevice>>,
1243 #[serde(skip_serializing_if = "Option::is_none")]
1244 pub devices_from: Option<Vec<String>>,
1246 #[serde(skip_serializing_if = "Option::is_none")]
1247 pub host_device_list: Option<Vec<LinuxDevice>>,
1249 #[serde(skip_serializing_if = "Option::is_none")]
1250 pub image: Option<String>,
1256 #[serde(skip_serializing_if = "Option::is_none")]
1257 pub image_volume_mode: Option<String>,
1263 #[serde(skip_serializing_if = "Option::is_none")]
1264 pub image_volumes: Option<Vec<ImageVolume>>,
1267 #[serde(skip_serializing_if = "Option::is_none")]
1268 pub init: Option<bool>,
1271 #[serde(skip_serializing_if = "Option::is_none")]
1272 pub init_path: Option<String>,
1277 pub ipcns: Option<Namespace>,
1278 #[serde(skip_serializing_if = "Option::is_none")]
1279 pub mounts: Option<Vec<Mount>>,
1284 #[serde(skip_serializing_if = "Option::is_none")]
1285 pub overlay_volumes: Option<Vec<OverlayVolume>>,
1288 #[serde(skip_serializing_if = "Option::is_none")]
1289 pub rootfs: Option<String>,
1295 #[serde(skip_serializing_if = "Option::is_none")]
1296 pub rootfs_mapping: Option<String>,
1298 #[serde(skip_serializing_if = "Option::is_none")]
1299 pub rootfs_overlay: Option<bool>,
1301 #[serde(skip_serializing_if = "Option::is_none")]
1302 pub rootfs_propagation: Option<String>,
1306 #[serde(skip_serializing_if = "Option::is_none")]
1307 pub secrets: Option<Vec<Secret>>,
1310 #[serde(skip_serializing_if = "Option::is_none")]
1311 pub shm_size: Option<i64>,
1315 #[serde(skip_serializing_if = "Option::is_none")]
1316 pub shm_size_systemd: Option<i64>,
1320 #[serde(skip_serializing_if = "Option::is_none")]
1321 pub storage_opts: Option<HashMap<String, String>>,
1324 #[serde(skip_serializing_if = "Option::is_none")]
1325 pub volatile: Option<bool>,
1328 #[serde(skip_serializing_if = "Option::is_none")]
1329 pub volumes: Option<Vec<NamedVolume>>,
1334 #[serde(skip_serializing_if = "Option::is_none")]
1335 pub volumes_from: Option<Vec<String>>,
1341 #[serde(skip_serializing_if = "Option::is_none")]
1342 pub work_dir: Option<String>,
1346}
1347
1348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1349pub struct ContainerTopOkBody {
1351 #[serde(rename = "Processes")]
1352 #[serde(default)]
1353 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1354 pub processes: Vec<Vec<String>>,
1357 #[serde(rename = "Titles")]
1358 #[serde(default)]
1359 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1360 pub titles: Vec<String>,
1362}
1363
1364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1365pub struct ContainerUpdateOkBody {
1367 #[serde(rename = "Warnings")]
1368 #[serde(default)]
1369 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1370 pub warnings: Vec<String>,
1372}
1373
1374pub type ContainerWaitLibpod200Response = i32;
1376
1377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1378pub struct ContainersPruneReport {
1379 #[serde(rename = "ContainersDeleted")]
1380 #[serde(skip_serializing_if = "Option::is_none")]
1381 pub containers_deleted: Option<Vec<String>>,
1382 #[serde(rename = "SpaceReclaimed")]
1383 #[serde(skip_serializing_if = "Option::is_none")]
1384 pub space_reclaimed: Option<u64>,
1385}
1386
1387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1388pub struct ContainersPruneReportLibpod {
1389 #[serde(rename = "Err")]
1390 #[serde(skip_serializing_if = "Option::is_none")]
1391 pub err: Option<String>,
1394 #[serde(rename = "Id")]
1395 #[serde(skip_serializing_if = "Option::is_none")]
1396 pub id: Option<String>,
1397 #[serde(rename = "Size")]
1398 #[serde(skip_serializing_if = "Option::is_none")]
1399 pub size: Option<i64>,
1400}
1401
1402#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1403pub struct CreateContainerConfig {
1405 #[serde(rename = "ArgsEscaped")]
1406 #[serde(skip_serializing_if = "Option::is_none")]
1407 pub args_escaped: Option<bool>,
1408 #[serde(rename = "AttachStderr")]
1409 #[serde(skip_serializing_if = "Option::is_none")]
1410 pub attach_stderr: Option<bool>,
1411 #[serde(rename = "AttachStdin")]
1412 #[serde(skip_serializing_if = "Option::is_none")]
1413 pub attach_stdin: Option<bool>,
1414 #[serde(rename = "AttachStdout")]
1415 #[serde(skip_serializing_if = "Option::is_none")]
1416 pub attach_stdout: Option<bool>,
1417 #[serde(rename = "Cmd")]
1418 pub cmd: Option<StrSlice>,
1419 #[serde(rename = "Domainname")]
1420 #[serde(skip_serializing_if = "Option::is_none")]
1421 pub domainname: Option<String>,
1422 #[serde(rename = "Entrypoint")]
1423 pub entrypoint: Option<StrSlice>,
1424 #[serde(rename = "Env")]
1425 #[serde(skip_serializing_if = "Option::is_none")]
1426 pub env: Option<Vec<String>>,
1427 #[serde(rename = "EnvMerge")]
1428 #[serde(skip_serializing_if = "Option::is_none")]
1429 pub env_merge: Option<Vec<String>>,
1430 #[serde(rename = "ExposedPorts")]
1431 pub exposed_ports: Option<PortSet>,
1432 #[serde(rename = "Healthcheck")]
1433 pub healthcheck: Option<HealthConfig>,
1434 #[serde(rename = "HostConfig")]
1435 pub host_config: Option<HostConfig>,
1436 #[serde(rename = "Hostname")]
1437 #[serde(skip_serializing_if = "Option::is_none")]
1438 pub hostname: Option<String>,
1439 #[serde(rename = "Image")]
1440 #[serde(skip_serializing_if = "Option::is_none")]
1441 pub image: Option<String>,
1442 #[serde(rename = "Labels")]
1443 #[serde(skip_serializing_if = "Option::is_none")]
1444 pub labels: Option<HashMap<String, String>>,
1445 #[serde(rename = "MacAddress")]
1446 #[serde(skip_serializing_if = "Option::is_none")]
1447 pub mac_address: Option<String>,
1448 #[serde(rename = "Name")]
1449 #[serde(skip_serializing_if = "Option::is_none")]
1450 pub name: Option<String>,
1451 #[serde(rename = "NetworkDisabled")]
1452 #[serde(skip_serializing_if = "Option::is_none")]
1453 pub network_disabled: Option<bool>,
1454 #[serde(rename = "NetworkingConfig")]
1455 pub networking_config: Option<NetworkingConfig>,
1456 #[serde(rename = "OnBuild")]
1457 #[serde(skip_serializing_if = "Option::is_none")]
1458 pub on_build: Option<Vec<String>>,
1459 #[serde(rename = "OpenStdin")]
1460 #[serde(skip_serializing_if = "Option::is_none")]
1461 pub open_stdin: Option<bool>,
1462 #[serde(rename = "Shell")]
1463 pub shell: Option<StrSlice>,
1464 #[serde(rename = "StdinOnce")]
1465 #[serde(skip_serializing_if = "Option::is_none")]
1466 pub stdin_once: Option<bool>,
1467 #[serde(rename = "StopSignal")]
1468 #[serde(skip_serializing_if = "Option::is_none")]
1469 pub stop_signal: Option<String>,
1470 #[serde(rename = "StopTimeout")]
1471 #[serde(skip_serializing_if = "Option::is_none")]
1472 pub stop_timeout: Option<i64>,
1473 #[serde(rename = "Tty")]
1474 #[serde(skip_serializing_if = "Option::is_none")]
1475 pub tty: Option<bool>,
1476 #[serde(rename = "UnsetEnv")]
1477 #[serde(skip_serializing_if = "Option::is_none")]
1478 pub unset_env: Option<Vec<String>>,
1479 #[serde(rename = "UnsetEnvAll")]
1480 #[serde(skip_serializing_if = "Option::is_none")]
1481 pub unset_env_all: Option<bool>,
1482 #[serde(rename = "User")]
1483 #[serde(skip_serializing_if = "Option::is_none")]
1484 pub user: Option<String>,
1485 #[serde(rename = "Volumes")]
1486 #[serde(skip_serializing_if = "Option::is_none")]
1487 pub volumes: Option<HashMap<String, Value>>,
1488 #[serde(rename = "WorkingDir")]
1489 #[serde(skip_serializing_if = "Option::is_none")]
1490 pub working_dir: Option<String>,
1491}
1492
1493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1494pub struct CreateOptions {
1496 #[serde(rename = "ClusterVolumeSpec")]
1497 pub cluster_volume_spec: Option<ClusterVolumeSpec>,
1498 #[serde(rename = "Driver")]
1499 #[serde(skip_serializing_if = "Option::is_none")]
1500 pub driver: Option<String>,
1502 #[serde(rename = "DriverOpts")]
1503 #[serde(skip_serializing_if = "Option::is_none")]
1504 pub driver_opts: Option<HashMap<String, String>>,
1507 #[serde(rename = "Labels")]
1508 #[serde(skip_serializing_if = "Option::is_none")]
1509 pub labels: Option<HashMap<String, String>>,
1511 #[serde(rename = "Name")]
1512 #[serde(skip_serializing_if = "Option::is_none")]
1513 pub name: Option<String>,
1515}
1516
1517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1518pub struct CreateResponse {
1520 #[serde(rename = "Id")]
1521 pub id: String,
1523 #[serde(rename = "Warnings")]
1524 #[serde(default)]
1525 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1526 pub warnings: Vec<String>,
1528}
1529
1530#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1531pub struct DeviceMapping {
1532 #[serde(rename = "CgroupPermissions")]
1533 #[serde(skip_serializing_if = "Option::is_none")]
1534 pub cgroup_permissions: Option<String>,
1535 #[serde(rename = "PathInContainer")]
1536 #[serde(skip_serializing_if = "Option::is_none")]
1537 pub path_in_container: Option<String>,
1538 #[serde(rename = "PathOnHost")]
1539 #[serde(skip_serializing_if = "Option::is_none")]
1540 pub path_on_host: Option<String>,
1541}
1542
1543#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1544pub struct DeviceRequest {
1546 #[serde(rename = "Capabilities")]
1547 #[serde(skip_serializing_if = "Option::is_none")]
1548 pub capabilities: Option<Vec<Vec<String>>>,
1549 #[serde(rename = "Count")]
1550 #[serde(skip_serializing_if = "Option::is_none")]
1551 pub count: Option<i64>,
1552 #[serde(rename = "DeviceIDs")]
1553 #[serde(skip_serializing_if = "Option::is_none")]
1554 pub device_i_ds: Option<Vec<String>>,
1555 #[serde(rename = "Driver")]
1556 #[serde(skip_serializing_if = "Option::is_none")]
1557 pub driver: Option<String>,
1558 #[serde(rename = "Options")]
1559 #[serde(skip_serializing_if = "Option::is_none")]
1560 pub options: Option<HashMap<String, String>>,
1561}
1562
1563pub type Digest = String;
1570
1571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1572pub struct Driver {
1573 #[serde(rename = "Name")]
1574 #[serde(skip_serializing_if = "Option::is_none")]
1575 pub name: Option<String>,
1576 #[serde(rename = "Options")]
1577 #[serde(skip_serializing_if = "Option::is_none")]
1578 pub options: Option<HashMap<String, String>>,
1579}
1580
1581#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1582pub struct DriverData {
1584 #[serde(rename = "Data")]
1585 #[serde(skip_serializing_if = "Option::is_none")]
1586 pub data: Option<HashMap<String, String>>,
1587 #[serde(rename = "Name")]
1588 #[serde(skip_serializing_if = "Option::is_none")]
1589 pub name: Option<String>,
1590}
1591
1592pub type Duration = i64;
1596
1597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1598pub struct EndpointIpamConfig {
1600 #[serde(rename = "IPv4Address")]
1601 #[serde(skip_serializing_if = "Option::is_none")]
1602 pub i_pv_4_address: Option<String>,
1603 #[serde(rename = "IPv6Address")]
1604 #[serde(skip_serializing_if = "Option::is_none")]
1605 pub i_pv_6_address: Option<String>,
1606 #[serde(rename = "LinkLocalIPs")]
1607 #[serde(skip_serializing_if = "Option::is_none")]
1608 pub link_local_i_ps: Option<Vec<String>>,
1609}
1610
1611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1612pub struct EndpointResource {
1614 #[serde(rename = "EndpointID")]
1615 #[serde(skip_serializing_if = "Option::is_none")]
1616 pub endpoint_id: Option<String>,
1617 #[serde(rename = "IPv4Address")]
1618 #[serde(skip_serializing_if = "Option::is_none")]
1619 pub i_pv_4_address: Option<String>,
1620 #[serde(rename = "IPv6Address")]
1621 #[serde(skip_serializing_if = "Option::is_none")]
1622 pub i_pv_6_address: Option<String>,
1623 #[serde(rename = "MacAddress")]
1624 #[serde(skip_serializing_if = "Option::is_none")]
1625 pub mac_address: Option<String>,
1626 #[serde(rename = "Name")]
1627 #[serde(skip_serializing_if = "Option::is_none")]
1628 pub name: Option<String>,
1629}
1630
1631#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1632pub struct EndpointSettings {
1634 #[serde(rename = "Aliases")]
1635 #[serde(skip_serializing_if = "Option::is_none")]
1636 pub aliases: Option<Vec<String>>,
1637 #[serde(rename = "DriverOpts")]
1638 #[serde(skip_serializing_if = "Option::is_none")]
1639 pub driver_opts: Option<HashMap<String, String>>,
1640 #[serde(rename = "EndpointID")]
1641 #[serde(skip_serializing_if = "Option::is_none")]
1642 pub endpoint_id: Option<String>,
1643 #[serde(rename = "Gateway")]
1644 #[serde(skip_serializing_if = "Option::is_none")]
1645 pub gateway: Option<String>,
1646 #[serde(rename = "GlobalIPv6Address")]
1647 #[serde(skip_serializing_if = "Option::is_none")]
1648 pub global_i_pv_6_address: Option<String>,
1649 #[serde(rename = "GlobalIPv6PrefixLen")]
1650 #[serde(skip_serializing_if = "Option::is_none")]
1651 pub global_i_pv_6_prefix_len: Option<i64>,
1652 #[serde(rename = "IPAMConfig")]
1653 pub ipam_config: Option<EndpointIpamConfig>,
1654 #[serde(rename = "IPAddress")]
1655 #[serde(skip_serializing_if = "Option::is_none")]
1656 pub ip_address: Option<String>,
1657 #[serde(rename = "IPPrefixLen")]
1658 #[serde(skip_serializing_if = "Option::is_none")]
1659 pub ip_prefix_len: Option<i64>,
1660 #[serde(rename = "IPv6Gateway")]
1661 #[serde(skip_serializing_if = "Option::is_none")]
1662 pub i_pv_6_gateway: Option<String>,
1663 #[serde(rename = "Links")]
1664 #[serde(skip_serializing_if = "Option::is_none")]
1665 pub links: Option<Vec<String>>,
1666 #[serde(rename = "MacAddress")]
1667 #[serde(skip_serializing_if = "Option::is_none")]
1668 pub mac_address: Option<String>,
1669 #[serde(rename = "NetworkID")]
1670 #[serde(skip_serializing_if = "Option::is_none")]
1671 pub network_id: Option<String>,
1673}
1674
1675#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1676pub struct ErrorModel {
1678 #[serde(skip_serializing_if = "Option::is_none")]
1679 pub cause: Option<String>,
1681 #[serde(skip_serializing_if = "Option::is_none")]
1682 pub message: Option<String>,
1684 #[serde(skip_serializing_if = "Option::is_none")]
1685 pub response: Option<i64>,
1687}
1688
1689#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1690pub struct ErrorResponse {
1691 pub message: String,
1693}
1694
1695#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1696pub struct ExecStartControlParam {
1697 #[serde(rename = "Detach")]
1698 #[serde(skip_serializing_if = "Option::is_none")]
1699 pub detach: Option<bool>,
1701 #[serde(rename = "Tty")]
1702 #[serde(skip_serializing_if = "Option::is_none")]
1703 pub tty: Option<bool>,
1705}
1706
1707#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1708pub struct ExecStartLibpodControlParam {
1709 #[serde(rename = "Detach")]
1710 #[serde(skip_serializing_if = "Option::is_none")]
1711 pub detach: Option<bool>,
1713 #[serde(rename = "Tty")]
1714 #[serde(skip_serializing_if = "Option::is_none")]
1715 pub tty: Option<bool>,
1717 #[serde(skip_serializing_if = "Option::is_none")]
1718 pub h: Option<isize>,
1720 #[serde(skip_serializing_if = "Option::is_none")]
1721 pub w: Option<isize>,
1723}
1724
1725pub type FileMode = u32;
1730
1731pub type GenerateKubeLibpod200Response = Vec<u8>;
1733
1734pub type GenerateSystemdLibpod200Response = HashMap<String, String>;
1736
1737#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1738pub struct GraphDriverData {
1741 #[serde(rename = "Data")]
1742 #[serde(default)]
1743 #[serde(deserialize_with = "deserialize_nonoptional_map")]
1744 pub data: HashMap<String, String>,
1749 #[serde(rename = "Name")]
1750 pub name: String,
1752}
1753
1754pub type HardwareAddr = Vec<u8>;
1755
1756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1757pub struct Health {
1759 #[serde(rename = "FailingStreak")]
1760 #[serde(skip_serializing_if = "Option::is_none")]
1761 pub failing_streak: Option<i64>,
1762 #[serde(rename = "Log")]
1763 #[serde(skip_serializing_if = "Option::is_none")]
1764 pub log: Option<Vec<HealthcheckResult>>,
1765 #[serde(rename = "Status")]
1766 #[serde(skip_serializing_if = "Option::is_none")]
1767 pub status: Option<String>,
1768}
1769
1770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1771pub struct HealthCheckLog {
1773 #[serde(rename = "End")]
1774 #[serde(skip_serializing_if = "Option::is_none")]
1775 pub end: Option<String>,
1777 #[serde(rename = "ExitCode")]
1778 #[serde(skip_serializing_if = "Option::is_none")]
1779 pub exit_code: Option<i64>,
1781 #[serde(rename = "Output")]
1782 #[serde(skip_serializing_if = "Option::is_none")]
1783 pub output: Option<String>,
1785 #[serde(rename = "Start")]
1786 #[serde(skip_serializing_if = "Option::is_none")]
1787 pub start: Option<String>,
1789}
1790
1791pub type HealthCheckOnFailureAction = i64;
1794
1795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1796pub struct HealthCheckResults {
1798 #[serde(rename = "FailingStreak")]
1799 #[serde(skip_serializing_if = "Option::is_none")]
1800 pub failing_streak: Option<i64>,
1802 #[serde(rename = "Log")]
1803 #[serde(skip_serializing_if = "Option::is_none")]
1804 pub log: Option<Vec<HealthCheckLog>>,
1806 #[serde(rename = "Status")]
1807 #[serde(skip_serializing_if = "Option::is_none")]
1808 pub status: Option<String>,
1810}
1811
1812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1813pub struct HealthConfig {
1814 #[serde(rename = "Interval")]
1815 pub interval: Option<i64>,
1816 #[serde(rename = "Retries")]
1817 #[serde(skip_serializing_if = "Option::is_none")]
1818 pub retries: Option<i64>,
1821 #[serde(rename = "StartPeriod")]
1822 pub start_period: Option<i64>,
1823 #[serde(rename = "Test")]
1824 #[serde(skip_serializing_if = "Option::is_none")]
1825 pub test: Option<Vec<String>>,
1833 #[serde(rename = "Timeout")]
1834 pub timeout: Option<i64>,
1835}
1836
1837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1838pub struct HealthcheckResult {
1840 #[serde(rename = "End")]
1841 #[serde(skip_serializing_if = "Option::is_none")]
1842 pub end: Option<DateTime<Utc>>,
1843 #[serde(rename = "ExitCode")]
1844 #[serde(skip_serializing_if = "Option::is_none")]
1845 pub exit_code: Option<i64>,
1846 #[serde(rename = "Output")]
1847 #[serde(skip_serializing_if = "Option::is_none")]
1848 pub output: Option<String>,
1849 #[serde(rename = "Start")]
1850 #[serde(skip_serializing_if = "Option::is_none")]
1851 pub start: Option<DateTime<Utc>>,
1852}
1853
1854#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1855pub struct History {
1856 #[serde(skip_serializing_if = "Option::is_none")]
1857 pub author: Option<String>,
1859 #[serde(skip_serializing_if = "Option::is_none")]
1860 pub comment: Option<String>,
1862 #[serde(skip_serializing_if = "Option::is_none")]
1863 pub created: Option<DateTime<Utc>>,
1865 #[serde(skip_serializing_if = "Option::is_none")]
1866 pub created_by: Option<String>,
1868 #[serde(skip_serializing_if = "Option::is_none")]
1869 pub empty_layer: Option<bool>,
1871}
1872
1873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1874pub struct HistoryResponse {
1876 #[serde(rename = "Comment")]
1877 #[serde(skip_serializing_if = "Option::is_none")]
1878 pub comment: Option<String>,
1879 #[serde(rename = "Created")]
1880 #[serde(skip_serializing_if = "Option::is_none")]
1881 pub created: Option<i64>,
1882 #[serde(rename = "CreatedBy")]
1883 #[serde(skip_serializing_if = "Option::is_none")]
1884 pub created_by: Option<String>,
1885 #[serde(rename = "Id")]
1886 #[serde(skip_serializing_if = "Option::is_none")]
1887 pub id: Option<String>,
1888 #[serde(rename = "Size")]
1889 #[serde(skip_serializing_if = "Option::is_none")]
1890 pub size: Option<i64>,
1891 #[serde(rename = "Tags")]
1892 #[serde(skip_serializing_if = "Option::is_none")]
1893 pub tags: Option<Vec<String>>,
1894}
1895
1896#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1897pub struct HistoryResponseItem {
1899 #[serde(rename = "Comment")]
1900 pub comment: String,
1902 #[serde(rename = "Created")]
1903 pub created: i64,
1905 #[serde(rename = "CreatedBy")]
1906 pub created_by: String,
1908 #[serde(rename = "Id")]
1909 pub id: String,
1911 #[serde(rename = "Size")]
1912 pub size: i64,
1914 #[serde(rename = "Tags")]
1915 #[serde(default)]
1916 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1917 pub tags: Vec<String>,
1919}
1920
1921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1922pub struct HostConfig {
1925 #[serde(rename = "AutoRemove")]
1926 #[serde(skip_serializing_if = "Option::is_none")]
1927 pub auto_remove: Option<bool>,
1928 #[serde(rename = "Binds")]
1929 #[serde(skip_serializing_if = "Option::is_none")]
1930 pub binds: Option<Vec<String>>,
1932 #[serde(rename = "BlkioDeviceReadBps")]
1933 #[serde(skip_serializing_if = "Option::is_none")]
1934 pub blkio_device_read_bps: Option<Vec<ThrottleDevice>>,
1935 #[serde(rename = "BlkioDeviceReadIOps")]
1936 #[serde(skip_serializing_if = "Option::is_none")]
1937 pub blkio_device_read_i_ops: Option<Vec<ThrottleDevice>>,
1938 #[serde(rename = "BlkioDeviceWriteBps")]
1939 #[serde(skip_serializing_if = "Option::is_none")]
1940 pub blkio_device_write_bps: Option<Vec<ThrottleDevice>>,
1941 #[serde(rename = "BlkioDeviceWriteIOps")]
1942 #[serde(skip_serializing_if = "Option::is_none")]
1943 pub blkio_device_write_i_ops: Option<Vec<ThrottleDevice>>,
1944 #[serde(rename = "BlkioWeight")]
1945 #[serde(skip_serializing_if = "Option::is_none")]
1946 pub blkio_weight: Option<u16>,
1947 #[serde(rename = "BlkioWeightDevice")]
1948 #[serde(skip_serializing_if = "Option::is_none")]
1949 pub blkio_weight_device: Option<Vec<WeightDevice>>,
1950 #[serde(rename = "CapAdd")]
1951 pub cap_add: Option<StrSlice>,
1952 #[serde(rename = "CapDrop")]
1953 pub cap_drop: Option<StrSlice>,
1954 #[serde(rename = "Cgroup")]
1955 pub cgroup: Option<String>,
1956 #[serde(rename = "CgroupParent")]
1957 #[serde(skip_serializing_if = "Option::is_none")]
1958 pub cgroup_parent: Option<String>,
1960 #[serde(rename = "CgroupnsMode")]
1961 pub cgroupns_mode: Option<String>,
1962 #[serde(rename = "ConsoleSize")]
1963 #[serde(skip_serializing_if = "Option::is_none")]
1964 pub console_size: Option<Vec<u64>>,
1965 #[serde(rename = "ContainerIDFile")]
1966 #[serde(skip_serializing_if = "Option::is_none")]
1967 pub container_id_file: Option<String>,
1968 #[serde(rename = "CpuCount")]
1969 #[serde(skip_serializing_if = "Option::is_none")]
1970 pub cpu_count: Option<i64>,
1972 #[serde(rename = "CpuPercent")]
1973 #[serde(skip_serializing_if = "Option::is_none")]
1974 pub cpu_percent: Option<i64>,
1975 #[serde(rename = "CpuPeriod")]
1976 #[serde(skip_serializing_if = "Option::is_none")]
1977 pub cpu_period: Option<i64>,
1978 #[serde(rename = "CpuQuota")]
1979 #[serde(skip_serializing_if = "Option::is_none")]
1980 pub cpu_quota: Option<i64>,
1981 #[serde(rename = "CpuRealtimePeriod")]
1982 #[serde(skip_serializing_if = "Option::is_none")]
1983 pub cpu_realtime_period: Option<i64>,
1984 #[serde(rename = "CpuRealtimeRuntime")]
1985 #[serde(skip_serializing_if = "Option::is_none")]
1986 pub cpu_realtime_runtime: Option<i64>,
1987 #[serde(rename = "CpuShares")]
1988 #[serde(skip_serializing_if = "Option::is_none")]
1989 pub cpu_shares: Option<i64>,
1991 #[serde(rename = "CpusetCpus")]
1992 #[serde(skip_serializing_if = "Option::is_none")]
1993 pub cpuset_cpus: Option<String>,
1994 #[serde(rename = "CpusetMems")]
1995 #[serde(skip_serializing_if = "Option::is_none")]
1996 pub cpuset_mems: Option<String>,
1997 #[serde(rename = "DeviceCgroupRules")]
1998 #[serde(skip_serializing_if = "Option::is_none")]
1999 pub device_cgroup_rules: Option<Vec<String>>,
2000 #[serde(rename = "DeviceRequests")]
2001 #[serde(skip_serializing_if = "Option::is_none")]
2002 pub device_requests: Option<Vec<DeviceRequest>>,
2003 #[serde(rename = "Devices")]
2004 #[serde(skip_serializing_if = "Option::is_none")]
2005 pub devices: Option<Vec<DeviceMapping>>,
2006 #[serde(rename = "Dns")]
2007 #[serde(skip_serializing_if = "Option::is_none")]
2008 pub dns: Option<Vec<String>>,
2009 #[serde(rename = "DnsOptions")]
2010 #[serde(skip_serializing_if = "Option::is_none")]
2011 pub dns_options: Option<Vec<String>>,
2012 #[serde(rename = "DnsSearch")]
2013 #[serde(skip_serializing_if = "Option::is_none")]
2014 pub dns_search: Option<Vec<String>>,
2015 #[serde(rename = "ExtraHosts")]
2016 #[serde(skip_serializing_if = "Option::is_none")]
2017 pub extra_hosts: Option<Vec<String>>,
2018 #[serde(rename = "GroupAdd")]
2019 #[serde(skip_serializing_if = "Option::is_none")]
2020 pub group_add: Option<Vec<String>>,
2021 #[serde(rename = "IOMaximumBandwidth")]
2022 #[serde(skip_serializing_if = "Option::is_none")]
2023 pub io_maximum_bandwidth: Option<u64>,
2024 #[serde(rename = "IOMaximumIOps")]
2025 #[serde(skip_serializing_if = "Option::is_none")]
2026 pub io_maximum_i_ops: Option<u64>,
2027 #[serde(rename = "Init")]
2028 #[serde(skip_serializing_if = "Option::is_none")]
2029 pub init: Option<bool>,
2031 #[serde(rename = "IpcMode")]
2032 pub ipc_mode: Option<String>,
2033 #[serde(rename = "Isolation")]
2034 pub isolation: Option<String>,
2035 #[serde(rename = "KernelMemory")]
2036 #[serde(skip_serializing_if = "Option::is_none")]
2037 pub kernel_memory: Option<i64>,
2040 #[serde(rename = "KernelMemoryTCP")]
2041 #[serde(skip_serializing_if = "Option::is_none")]
2042 pub kernel_memory_tcp: Option<i64>,
2043 #[serde(rename = "Links")]
2044 #[serde(skip_serializing_if = "Option::is_none")]
2045 pub links: Option<Vec<String>>,
2046 #[serde(rename = "LogConfig")]
2047 pub log_config: Option<LogConfig>,
2048 #[serde(rename = "MaskedPaths")]
2049 #[serde(skip_serializing_if = "Option::is_none")]
2050 pub masked_paths: Option<Vec<String>>,
2052 #[serde(rename = "Memory")]
2053 #[serde(skip_serializing_if = "Option::is_none")]
2054 pub memory: Option<i64>,
2055 #[serde(rename = "MemoryReservation")]
2056 #[serde(skip_serializing_if = "Option::is_none")]
2057 pub memory_reservation: Option<i64>,
2058 #[serde(rename = "MemorySwap")]
2059 #[serde(skip_serializing_if = "Option::is_none")]
2060 pub memory_swap: Option<i64>,
2061 #[serde(rename = "MemorySwappiness")]
2062 #[serde(skip_serializing_if = "Option::is_none")]
2063 pub memory_swappiness: Option<i64>,
2064 #[serde(rename = "Mounts")]
2065 #[serde(skip_serializing_if = "Option::is_none")]
2066 pub mounts: Option<Vec<Mount>>,
2068 #[serde(rename = "NanoCpus")]
2069 #[serde(skip_serializing_if = "Option::is_none")]
2070 pub nano_cpus: Option<i64>,
2071 #[serde(rename = "NetworkMode")]
2072 pub network_mode: Option<String>,
2073 #[serde(rename = "OomKillDisable")]
2074 #[serde(skip_serializing_if = "Option::is_none")]
2075 pub oom_kill_disable: Option<bool>,
2076 #[serde(rename = "OomScoreAdj")]
2077 #[serde(skip_serializing_if = "Option::is_none")]
2078 pub oom_score_adj: Option<i64>,
2079 #[serde(rename = "PidMode")]
2080 pub pid_mode: Option<String>,
2081 #[serde(rename = "PidsLimit")]
2082 #[serde(skip_serializing_if = "Option::is_none")]
2083 pub pids_limit: Option<i64>,
2084 #[serde(rename = "PortBindings")]
2085 pub port_bindings: Option<PortMap>,
2086 #[serde(rename = "Privileged")]
2087 #[serde(skip_serializing_if = "Option::is_none")]
2088 pub privileged: Option<bool>,
2089 #[serde(rename = "PublishAllPorts")]
2090 #[serde(skip_serializing_if = "Option::is_none")]
2091 pub publish_all_ports: Option<bool>,
2092 #[serde(rename = "ReadonlyPaths")]
2093 #[serde(skip_serializing_if = "Option::is_none")]
2094 pub readonly_paths: Option<Vec<String>>,
2096 #[serde(rename = "ReadonlyRootfs")]
2097 #[serde(skip_serializing_if = "Option::is_none")]
2098 pub readonly_rootfs: Option<bool>,
2099 #[serde(rename = "RestartPolicy")]
2100 pub restart_policy: Option<RestartPolicy>,
2101 #[serde(rename = "Runtime")]
2102 #[serde(skip_serializing_if = "Option::is_none")]
2103 pub runtime: Option<String>,
2104 #[serde(rename = "SecurityOpt")]
2105 #[serde(skip_serializing_if = "Option::is_none")]
2106 pub security_opt: Option<Vec<String>>,
2107 #[serde(rename = "ShmSize")]
2108 #[serde(skip_serializing_if = "Option::is_none")]
2109 pub shm_size: Option<i64>,
2110 #[serde(rename = "StorageOpt")]
2111 #[serde(skip_serializing_if = "Option::is_none")]
2112 pub storage_opt: Option<HashMap<String, String>>,
2113 #[serde(rename = "Sysctls")]
2114 #[serde(skip_serializing_if = "Option::is_none")]
2115 pub sysctls: Option<HashMap<String, String>>,
2116 #[serde(rename = "Tmpfs")]
2117 #[serde(skip_serializing_if = "Option::is_none")]
2118 pub tmpfs: Option<HashMap<String, String>>,
2119 #[serde(rename = "UTSMode")]
2120 pub uts_mode: Option<String>,
2121 #[serde(rename = "Ulimits")]
2122 #[serde(skip_serializing_if = "Option::is_none")]
2123 pub ulimits: Option<Vec<Ulimit>>,
2124 #[serde(rename = "UsernsMode")]
2125 pub userns_mode: Option<String>,
2126 #[serde(rename = "VolumeDriver")]
2127 #[serde(skip_serializing_if = "Option::is_none")]
2128 pub volume_driver: Option<String>,
2129 #[serde(rename = "VolumesFrom")]
2130 #[serde(skip_serializing_if = "Option::is_none")]
2131 pub volumes_from: Option<Vec<String>>,
2132}
2133
2134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2135pub struct IdMap {
2139 #[serde(skip_serializing_if = "Option::is_none")]
2140 pub container_id: Option<i64>,
2141 #[serde(skip_serializing_if = "Option::is_none")]
2142 pub host_id: Option<i64>,
2143 #[serde(skip_serializing_if = "Option::is_none")]
2144 pub size: Option<i64>,
2145}
2146
2147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2148pub struct IdMappingOptions {
2151 #[serde(rename = "AutoUserNs")]
2152 #[serde(skip_serializing_if = "Option::is_none")]
2153 pub auto_user_ns: Option<bool>,
2154 #[serde(rename = "AutoUserNsOpts")]
2155 pub auto_user_ns_opts: Option<AutoUserNsOptions>,
2156 #[serde(rename = "GIDMap")]
2157 #[serde(skip_serializing_if = "Option::is_none")]
2158 pub gid_map: Option<Vec<IdMap>>,
2159 #[serde(rename = "HostGIDMapping")]
2160 #[serde(skip_serializing_if = "Option::is_none")]
2161 pub host_gid_mapping: Option<bool>,
2162 #[serde(rename = "HostUIDMapping")]
2163 #[serde(skip_serializing_if = "Option::is_none")]
2164 pub host_uid_mapping: Option<bool>,
2174 #[serde(rename = "UIDMap")]
2175 #[serde(skip_serializing_if = "Option::is_none")]
2176 pub uid_map: Option<Vec<IdMap>>,
2177}
2178
2179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2180pub struct Ipam {
2182 #[serde(rename = "Config")]
2183 #[serde(skip_serializing_if = "Option::is_none")]
2184 pub config: Option<Vec<IpamConfig>>,
2185 #[serde(rename = "Driver")]
2186 #[serde(skip_serializing_if = "Option::is_none")]
2187 pub driver: Option<String>,
2188 #[serde(rename = "Options")]
2189 #[serde(skip_serializing_if = "Option::is_none")]
2190 pub options: Option<HashMap<String, String>>,
2191}
2192
2193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2194pub struct IpamConfig {
2196 #[serde(rename = "AuxiliaryAddresses")]
2197 #[serde(skip_serializing_if = "Option::is_none")]
2198 pub auxiliary_addresses: Option<HashMap<String, String>>,
2199 #[serde(rename = "Gateway")]
2200 #[serde(skip_serializing_if = "Option::is_none")]
2201 pub gateway: Option<String>,
2202 #[serde(rename = "IPRange")]
2203 #[serde(skip_serializing_if = "Option::is_none")]
2204 pub ip_range: Option<String>,
2205 #[serde(rename = "Subnet")]
2206 #[serde(skip_serializing_if = "Option::is_none")]
2207 pub subnet: Option<String>,
2208}
2209
2210pub type IpMask = Vec<u8>;
2212
2213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2214pub struct IpNet {
2215 #[serde(rename = "IP")]
2216 #[serde(skip_serializing_if = "Option::is_none")]
2217 pub ip: Option<String>,
2218 #[serde(rename = "Mask")]
2219 pub mask: Option<IpMask>,
2220}
2221
2222#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2223pub struct IdResponse {
2225 #[serde(rename = "Id")]
2226 pub id: String,
2228}
2229
2230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2231pub struct ImageBuild200Response {
2233 pub stream: String,
2235}
2236
2237pub type ImageBuildInputStreamParam = Vec<u8>;
2238
2239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2240pub struct ImageBuildLibpod200Response {
2242 pub stream: String,
2244}
2245
2246#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2247pub struct ImageConfig {
2248 #[serde(rename = "ArgsEscaped")]
2249 #[serde(skip_serializing_if = "Option::is_none")]
2250 pub args_escaped: Option<bool>,
2258 #[serde(rename = "Cmd")]
2259 #[serde(skip_serializing_if = "Option::is_none")]
2260 pub cmd: Option<Vec<String>>,
2262 #[serde(rename = "Entrypoint")]
2263 #[serde(skip_serializing_if = "Option::is_none")]
2264 pub entrypoint: Option<Vec<String>>,
2266 #[serde(rename = "Env")]
2267 #[serde(skip_serializing_if = "Option::is_none")]
2268 pub env: Option<Vec<String>>,
2270 #[serde(rename = "ExposedPorts")]
2271 #[serde(skip_serializing_if = "Option::is_none")]
2272 pub exposed_ports: Option<HashMap<String, Value>>,
2274 #[serde(rename = "Labels")]
2275 #[serde(skip_serializing_if = "Option::is_none")]
2276 pub labels: Option<HashMap<String, String>>,
2278 #[serde(rename = "StopSignal")]
2279 #[serde(skip_serializing_if = "Option::is_none")]
2280 pub stop_signal: Option<String>,
2282 #[serde(rename = "User")]
2283 #[serde(skip_serializing_if = "Option::is_none")]
2284 pub user: Option<String>,
2286 #[serde(rename = "Volumes")]
2287 #[serde(skip_serializing_if = "Option::is_none")]
2288 pub volumes: Option<HashMap<String, Value>>,
2290 #[serde(rename = "WorkingDir")]
2291 #[serde(skip_serializing_if = "Option::is_none")]
2292 pub working_dir: Option<String>,
2294}
2295
2296pub type ImageCreate200Response = Vec<u8>;
2298
2299pub type ImageCreateInputImageParam = Vec<u8>;
2300
2301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2302pub struct ImageData {
2303 #[serde(rename = "Annotations")]
2304 #[serde(skip_serializing_if = "Option::is_none")]
2305 pub annotations: Option<HashMap<String, String>>,
2306 #[serde(rename = "Architecture")]
2307 #[serde(skip_serializing_if = "Option::is_none")]
2308 pub architecture: Option<String>,
2309 #[serde(rename = "Author")]
2310 #[serde(skip_serializing_if = "Option::is_none")]
2311 pub author: Option<String>,
2312 #[serde(rename = "Comment")]
2313 #[serde(skip_serializing_if = "Option::is_none")]
2314 pub comment: Option<String>,
2315 #[serde(rename = "Config")]
2316 pub config: Option<ImageConfig>,
2317 #[serde(rename = "Created")]
2318 #[serde(skip_serializing_if = "Option::is_none")]
2319 pub created: Option<DateTime<Utc>>,
2320 #[serde(rename = "Digest")]
2321 pub digest: Option<String>,
2322 #[serde(rename = "GraphDriver")]
2323 pub graph_driver: Option<DriverData>,
2324 #[serde(rename = "Healthcheck")]
2325 pub healthcheck: Option<Schema2HealthConfig>,
2326 #[serde(rename = "History")]
2327 #[serde(skip_serializing_if = "Option::is_none")]
2328 pub history: Option<Vec<History>>,
2329 #[serde(rename = "Id")]
2330 #[serde(skip_serializing_if = "Option::is_none")]
2331 pub id: Option<String>,
2332 #[serde(rename = "Labels")]
2333 #[serde(skip_serializing_if = "Option::is_none")]
2334 pub labels: Option<HashMap<String, String>>,
2335 #[serde(rename = "ManifestType")]
2336 #[serde(skip_serializing_if = "Option::is_none")]
2337 pub manifest_type: Option<String>,
2338 #[serde(rename = "NamesHistory")]
2339 #[serde(skip_serializing_if = "Option::is_none")]
2340 pub names_history: Option<Vec<String>>,
2341 #[serde(rename = "Os")]
2342 #[serde(skip_serializing_if = "Option::is_none")]
2343 pub os: Option<String>,
2344 #[serde(rename = "Parent")]
2345 #[serde(skip_serializing_if = "Option::is_none")]
2346 pub parent: Option<String>,
2347 #[serde(rename = "RepoDigests")]
2348 #[serde(skip_serializing_if = "Option::is_none")]
2349 pub repo_digests: Option<Vec<String>>,
2350 #[serde(rename = "RepoTags")]
2351 #[serde(skip_serializing_if = "Option::is_none")]
2352 pub repo_tags: Option<Vec<String>>,
2353 #[serde(rename = "RootFS")]
2354 pub root_fs: Option<RootFs>,
2355 #[serde(rename = "Size")]
2356 #[serde(skip_serializing_if = "Option::is_none")]
2357 pub size: Option<i64>,
2358 #[serde(rename = "User")]
2359 #[serde(skip_serializing_if = "Option::is_none")]
2360 pub user: Option<String>,
2361 #[serde(rename = "Version")]
2362 #[serde(skip_serializing_if = "Option::is_none")]
2363 pub version: Option<String>,
2364 #[serde(rename = "VirtualSize")]
2365 #[serde(skip_serializing_if = "Option::is_none")]
2366 pub virtual_size: Option<i64>,
2367}
2368
2369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2370pub struct ImageDeleteResponseItem {
2372 #[serde(rename = "Deleted")]
2373 #[serde(skip_serializing_if = "Option::is_none")]
2374 pub deleted: Option<String>,
2376 #[serde(rename = "Untagged")]
2377 #[serde(skip_serializing_if = "Option::is_none")]
2378 pub untagged: Option<String>,
2380}
2381
2382pub type ImageExportLibpod200Response = Vec<u8>;
2384
2385pub type ImageGet200Response = Vec<u8>;
2387
2388pub type ImageGetAll200Response = Vec<u8>;
2390
2391pub type ImageGetLibpod200Response = Vec<u8>;
2393
2394pub type ImageImportLibpodUploadParam = Vec<u8>;
2395
2396#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2397pub struct ImageImportReport {
2398 #[serde(rename = "Id")]
2399 #[serde(skip_serializing_if = "Option::is_none")]
2400 pub id: Option<String>,
2401}
2402
2403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2404pub struct ImageInspect {
2405 #[serde(rename = "Architecture")]
2406 #[serde(skip_serializing_if = "Option::is_none")]
2407 pub architecture: Option<String>,
2409 #[serde(rename = "Author")]
2410 #[serde(skip_serializing_if = "Option::is_none")]
2411 pub author: Option<String>,
2414 #[serde(rename = "Comment")]
2415 #[serde(skip_serializing_if = "Option::is_none")]
2416 pub comment: Option<String>,
2419 #[serde(rename = "Config")]
2420 pub config: Option<Config>,
2421 #[serde(rename = "Container")]
2422 #[serde(skip_serializing_if = "Option::is_none")]
2423 pub container: Option<String>,
2427 #[serde(rename = "ContainerConfig")]
2428 pub container_config: Option<Config>,
2429 #[serde(rename = "Created")]
2430 #[serde(skip_serializing_if = "Option::is_none")]
2431 pub created: Option<String>,
2434 #[serde(rename = "DockerVersion")]
2435 #[serde(skip_serializing_if = "Option::is_none")]
2436 pub docker_version: Option<String>,
2440 #[serde(rename = "GraphDriver")]
2441 pub graph_driver: Option<GraphDriverData>,
2442 #[serde(rename = "Id")]
2443 #[serde(skip_serializing_if = "Option::is_none")]
2444 pub id: Option<String>,
2453 #[serde(rename = "Metadata")]
2454 pub metadata: Option<ImageMetadata>,
2455 #[serde(rename = "Os")]
2456 #[serde(skip_serializing_if = "Option::is_none")]
2457 pub os: Option<String>,
2459 #[serde(rename = "OsVersion")]
2460 #[serde(skip_serializing_if = "Option::is_none")]
2461 pub os_version: Option<String>,
2464 #[serde(rename = "Parent")]
2465 #[serde(skip_serializing_if = "Option::is_none")]
2466 pub parent: Option<String>,
2472 #[serde(rename = "RepoDigests")]
2473 #[serde(skip_serializing_if = "Option::is_none")]
2474 pub repo_digests: Option<Vec<String>>,
2482 #[serde(rename = "RepoTags")]
2483 #[serde(skip_serializing_if = "Option::is_none")]
2484 pub repo_tags: Option<Vec<String>>,
2491 #[serde(rename = "RootFS")]
2492 pub root_fs: Option<RootFs>,
2493 #[serde(rename = "Size")]
2494 #[serde(skip_serializing_if = "Option::is_none")]
2495 pub size: Option<i64>,
2497 #[serde(rename = "Variant")]
2498 #[serde(skip_serializing_if = "Option::is_none")]
2499 pub variant: Option<String>,
2501 #[serde(rename = "VirtualSize")]
2502 #[serde(skip_serializing_if = "Option::is_none")]
2503 pub virtual_size: Option<i64>,
2514}
2515
2516pub type ImageLoadLibpodUploadParam = String;
2517
2518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2519pub struct ImageLoadReport {
2520 #[serde(rename = "Names")]
2521 #[serde(skip_serializing_if = "Option::is_none")]
2522 pub names: Option<Vec<String>>,
2523}
2524
2525pub type ImageLoadRequestParam = String;
2526
2527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2528pub struct ImageMetadata {
2530 #[serde(rename = "LastTagTime")]
2531 #[serde(skip_serializing_if = "Option::is_none")]
2532 pub last_tag_time: Option<DateTime<Utc>>,
2534}
2535
2536pub type ImagePush200Response = Vec<u8>;
2538
2539pub type ImagePushLibpod200Response = Vec<u8>;
2541
2542#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2543pub struct ImageSummary {
2545 #[serde(rename = "Containers")]
2546 pub containers: i64,
2552 #[serde(rename = "Created")]
2553 pub created: i64,
2556 #[serde(rename = "Id")]
2557 pub id: String,
2566 #[serde(rename = "Labels")]
2567 #[serde(default)]
2568 #[serde(deserialize_with = "deserialize_nonoptional_map")]
2569 pub labels: HashMap<String, String>,
2571 #[serde(rename = "ParentId")]
2572 pub parent_id: String,
2578 #[serde(rename = "RepoDigests")]
2579 #[serde(default)]
2580 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
2581 pub repo_digests: Vec<String>,
2589 #[serde(rename = "RepoTags")]
2590 #[serde(default)]
2591 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
2592 pub repo_tags: Vec<String>,
2599 #[serde(rename = "SharedSize")]
2600 pub shared_size: i64,
2606 #[serde(rename = "Size")]
2607 pub size: i64,
2609 #[serde(rename = "VirtualSize")]
2610 pub virtual_size: i64,
2620}
2621
2622#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2623pub struct ImageTreeReport {
2625 #[serde(rename = "Tree")]
2626 #[serde(skip_serializing_if = "Option::is_none")]
2627 pub tree: Option<String>,
2628}
2629
2630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2631pub struct ImageVolume {
2635 #[serde(rename = "Destination")]
2636 #[serde(skip_serializing_if = "Option::is_none")]
2637 pub destination: Option<String>,
2639 #[serde(rename = "ReadWrite")]
2640 #[serde(skip_serializing_if = "Option::is_none")]
2641 pub read_write: Option<bool>,
2643 #[serde(rename = "Source")]
2644 #[serde(skip_serializing_if = "Option::is_none")]
2645 pub source: Option<String>,
2648}
2649
2650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2651pub struct Info {
2654 #[serde(rename = "AccessibleTopology")]
2655 #[serde(skip_serializing_if = "Option::is_none")]
2656 pub accessible_topology: Option<Vec<Topology>>,
2659 #[serde(rename = "CapacityBytes")]
2660 #[serde(skip_serializing_if = "Option::is_none")]
2661 pub capacity_bytes: Option<i64>,
2664 #[serde(rename = "VolumeContext")]
2665 #[serde(skip_serializing_if = "Option::is_none")]
2666 pub volume_context: Option<HashMap<String, String>>,
2669 #[serde(rename = "VolumeID")]
2670 #[serde(skip_serializing_if = "Option::is_none")]
2671 pub volume_id: Option<String>,
2676}
2677
2678#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2679pub struct InspectAdditionalNetwork {
2684 #[serde(rename = "AdditionalMACAddresses")]
2685 #[serde(skip_serializing_if = "Option::is_none")]
2686 pub additional_mac_addresses: Option<Vec<String>>,
2690 #[serde(rename = "Aliases")]
2691 #[serde(skip_serializing_if = "Option::is_none")]
2692 pub aliases: Option<Vec<String>>,
2694 #[serde(rename = "DriverOpts")]
2695 #[serde(skip_serializing_if = "Option::is_none")]
2696 pub driver_opts: Option<HashMap<String, String>>,
2699 #[serde(rename = "EndpointID")]
2700 #[serde(skip_serializing_if = "Option::is_none")]
2701 pub endpoint_id: Option<String>,
2703 #[serde(rename = "Gateway")]
2704 #[serde(skip_serializing_if = "Option::is_none")]
2705 pub gateway: Option<String>,
2707 #[serde(rename = "GlobalIPv6Address")]
2708 #[serde(skip_serializing_if = "Option::is_none")]
2709 pub global_i_pv_6_address: Option<String>,
2711 #[serde(rename = "GlobalIPv6PrefixLen")]
2712 #[serde(skip_serializing_if = "Option::is_none")]
2713 pub global_i_pv_6_prefix_len: Option<i64>,
2715 #[serde(rename = "IPAMConfig")]
2716 #[serde(skip_serializing_if = "Option::is_none")]
2717 pub ipam_config: Option<HashMap<String, String>>,
2720 #[serde(rename = "IPAddress")]
2721 #[serde(skip_serializing_if = "Option::is_none")]
2722 pub ip_address: Option<String>,
2724 #[serde(rename = "IPPrefixLen")]
2725 #[serde(skip_serializing_if = "Option::is_none")]
2726 pub ip_prefix_len: Option<i64>,
2728 #[serde(rename = "IPv6Gateway")]
2729 #[serde(skip_serializing_if = "Option::is_none")]
2730 pub i_pv_6_gateway: Option<String>,
2732 #[serde(rename = "Links")]
2733 #[serde(skip_serializing_if = "Option::is_none")]
2734 pub links: Option<Vec<String>>,
2737 #[serde(rename = "MacAddress")]
2738 #[serde(skip_serializing_if = "Option::is_none")]
2739 pub mac_address: Option<String>,
2741 #[serde(rename = "NetworkID")]
2742 #[serde(skip_serializing_if = "Option::is_none")]
2743 pub network_id: Option<String>,
2745 #[serde(rename = "SecondaryIPAddresses")]
2746 #[serde(skip_serializing_if = "Option::is_none")]
2747 pub secondary_ip_addresses: Option<Vec<Address>>,
2750 #[serde(rename = "SecondaryIPv6Addresses")]
2751 #[serde(skip_serializing_if = "Option::is_none")]
2752 pub secondary_i_pv_6_addresses: Option<Vec<Address>>,
2755}
2756
2757#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2758pub struct InspectBlkioThrottleDevice {
2762 #[serde(rename = "Path")]
2763 #[serde(skip_serializing_if = "Option::is_none")]
2764 pub path: Option<String>,
2766 #[serde(rename = "Rate")]
2767 #[serde(skip_serializing_if = "Option::is_none")]
2768 pub rate: Option<u64>,
2772}
2773
2774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2775pub struct InspectBlkioWeightDevice {
2779 #[serde(rename = "Path")]
2780 #[serde(skip_serializing_if = "Option::is_none")]
2781 pub path: Option<String>,
2783 #[serde(rename = "Weight")]
2784 #[serde(skip_serializing_if = "Option::is_none")]
2785 pub weight: Option<u16>,
2788}
2789
2790#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2791pub struct InspectContainerConfig {
2794 #[serde(rename = "Annotations")]
2795 #[serde(skip_serializing_if = "Option::is_none")]
2796 pub annotations: Option<HashMap<String, String>>,
2798 #[serde(rename = "AttachStderr")]
2799 #[serde(skip_serializing_if = "Option::is_none")]
2800 pub attach_stderr: Option<bool>,
2802 #[serde(rename = "AttachStdin")]
2803 #[serde(skip_serializing_if = "Option::is_none")]
2804 pub attach_stdin: Option<bool>,
2806 #[serde(rename = "AttachStdout")]
2807 #[serde(skip_serializing_if = "Option::is_none")]
2808 pub attach_stdout: Option<bool>,
2810 #[serde(rename = "ChrootDirs")]
2811 #[serde(skip_serializing_if = "Option::is_none")]
2812 pub chroot_dirs: Option<Vec<String>>,
2816 #[serde(rename = "Cmd")]
2817 #[serde(skip_serializing_if = "Option::is_none")]
2818 pub cmd: Option<Vec<String>>,
2820 #[serde(rename = "CreateCommand")]
2821 #[serde(skip_serializing_if = "Option::is_none")]
2822 pub create_command: Option<Vec<String>>,
2825 #[serde(rename = "Domainname")]
2826 #[serde(skip_serializing_if = "Option::is_none")]
2827 pub domainname: Option<String>,
2829 #[serde(rename = "Entrypoint")]
2830 #[serde(skip_serializing_if = "Option::is_none")]
2831 pub entrypoint: Option<String>,
2833 #[serde(rename = "Env")]
2834 #[serde(skip_serializing_if = "Option::is_none")]
2835 pub env: Option<Vec<String>>,
2837 #[serde(rename = "Healthcheck")]
2838 pub healthcheck: Option<Schema2HealthConfig>,
2839 #[serde(rename = "HealthcheckOnFailureAction")]
2840 #[serde(skip_serializing_if = "Option::is_none")]
2841 pub healthcheck_on_failure_action: Option<String>,
2843 #[serde(rename = "Hostname")]
2844 #[serde(skip_serializing_if = "Option::is_none")]
2845 pub hostname: Option<String>,
2847 #[serde(rename = "Image")]
2848 #[serde(skip_serializing_if = "Option::is_none")]
2849 pub image: Option<String>,
2851 #[serde(rename = "Labels")]
2852 #[serde(skip_serializing_if = "Option::is_none")]
2853 pub labels: Option<HashMap<String, String>>,
2855 #[serde(rename = "OnBuild")]
2856 #[serde(skip_serializing_if = "Option::is_none")]
2857 pub on_build: Option<String>,
2859 #[serde(rename = "OpenStdin")]
2860 #[serde(skip_serializing_if = "Option::is_none")]
2861 pub open_stdin: Option<bool>,
2863 #[serde(rename = "Passwd")]
2864 #[serde(skip_serializing_if = "Option::is_none")]
2865 pub passwd: Option<bool>,
2867 #[serde(rename = "Secrets")]
2868 #[serde(skip_serializing_if = "Option::is_none")]
2869 pub secrets: Option<Vec<InspectSecret>>,
2871 #[serde(rename = "StdinOnce")]
2872 #[serde(skip_serializing_if = "Option::is_none")]
2873 pub stdin_once: Option<bool>,
2876 #[serde(rename = "StopSignal")]
2877 #[serde(skip_serializing_if = "Option::is_none")]
2878 pub stop_signal: Option<u64>,
2880 #[serde(rename = "StopTimeout")]
2881 #[serde(skip_serializing_if = "Option::is_none")]
2882 pub stop_timeout: Option<u64>,
2884 #[serde(rename = "SystemdMode")]
2885 #[serde(skip_serializing_if = "Option::is_none")]
2886 pub systemd_mode: Option<bool>,
2890 #[serde(rename = "Timeout")]
2891 #[serde(skip_serializing_if = "Option::is_none")]
2892 pub timeout: Option<u64>,
2894 #[serde(rename = "Timezone")]
2895 #[serde(skip_serializing_if = "Option::is_none")]
2896 pub timezone: Option<String>,
2899 #[serde(rename = "Tty")]
2900 #[serde(skip_serializing_if = "Option::is_none")]
2901 pub tty: Option<bool>,
2903 #[serde(rename = "Umask")]
2904 #[serde(skip_serializing_if = "Option::is_none")]
2905 pub umask: Option<String>,
2907 #[serde(rename = "User")]
2908 #[serde(skip_serializing_if = "Option::is_none")]
2909 pub user: Option<String>,
2911 #[serde(rename = "Volumes")]
2912 #[serde(skip_serializing_if = "Option::is_none")]
2913 pub volumes: Option<HashMap<String, Value>>,
2915 #[serde(rename = "WorkingDir")]
2916 #[serde(skip_serializing_if = "Option::is_none")]
2917 pub working_dir: Option<String>,
2919 #[serde(rename = "sdNotifyMode")]
2920 #[serde(skip_serializing_if = "Option::is_none")]
2921 pub sd_notify_mode: Option<String>,
2923 #[serde(rename = "sdNotifySocket")]
2924 #[serde(skip_serializing_if = "Option::is_none")]
2925 pub sd_notify_socket: Option<String>,
2927}
2928
2929#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2930pub struct InspectContainerData {
2936 #[serde(rename = "AppArmorProfile")]
2937 #[serde(skip_serializing_if = "Option::is_none")]
2938 pub app_armor_profile: Option<String>,
2939 #[serde(rename = "Args")]
2940 #[serde(skip_serializing_if = "Option::is_none")]
2941 pub args: Option<Vec<String>>,
2942 #[serde(rename = "BoundingCaps")]
2943 #[serde(skip_serializing_if = "Option::is_none")]
2944 pub bounding_caps: Option<Vec<String>>,
2945 #[serde(rename = "Config")]
2946 pub config: Option<InspectContainerConfig>,
2947 #[serde(rename = "ConmonPidFile")]
2948 #[serde(skip_serializing_if = "Option::is_none")]
2949 pub conmon_pid_file: Option<String>,
2950 #[serde(rename = "Created")]
2951 #[serde(skip_serializing_if = "Option::is_none")]
2952 pub created: Option<DateTime<Utc>>,
2953 #[serde(rename = "Dependencies")]
2954 #[serde(skip_serializing_if = "Option::is_none")]
2955 pub dependencies: Option<Vec<String>>,
2956 #[serde(rename = "Driver")]
2957 #[serde(skip_serializing_if = "Option::is_none")]
2958 pub driver: Option<String>,
2959 #[serde(rename = "EffectiveCaps")]
2960 #[serde(skip_serializing_if = "Option::is_none")]
2961 pub effective_caps: Option<Vec<String>>,
2962 #[serde(rename = "ExecIDs")]
2963 #[serde(skip_serializing_if = "Option::is_none")]
2964 pub exec_i_ds: Option<Vec<String>>,
2965 #[serde(rename = "GraphDriver")]
2966 pub graph_driver: Option<DriverData>,
2967 #[serde(rename = "HostConfig")]
2968 pub host_config: Option<InspectContainerHostConfig>,
2969 #[serde(rename = "HostnamePath")]
2970 #[serde(skip_serializing_if = "Option::is_none")]
2971 pub hostname_path: Option<String>,
2972 #[serde(rename = "HostsPath")]
2973 #[serde(skip_serializing_if = "Option::is_none")]
2974 pub hosts_path: Option<String>,
2975 #[serde(rename = "Id")]
2976 #[serde(skip_serializing_if = "Option::is_none")]
2977 pub id: Option<String>,
2978 #[serde(rename = "Image")]
2979 #[serde(skip_serializing_if = "Option::is_none")]
2980 pub image: Option<String>,
2981 #[serde(rename = "ImageDigest")]
2982 #[serde(skip_serializing_if = "Option::is_none")]
2983 pub image_digest: Option<String>,
2984 #[serde(rename = "ImageName")]
2985 #[serde(skip_serializing_if = "Option::is_none")]
2986 pub image_name: Option<String>,
2987 #[serde(rename = "IsInfra")]
2988 #[serde(skip_serializing_if = "Option::is_none")]
2989 pub is_infra: Option<bool>,
2990 #[serde(rename = "IsService")]
2991 #[serde(skip_serializing_if = "Option::is_none")]
2992 pub is_service: Option<bool>,
2993 #[serde(rename = "MountLabel")]
2994 #[serde(skip_serializing_if = "Option::is_none")]
2995 pub mount_label: Option<String>,
2996 #[serde(rename = "Mounts")]
2997 #[serde(skip_serializing_if = "Option::is_none")]
2998 pub mounts: Option<Vec<InspectMount>>,
2999 #[serde(rename = "Name")]
3000 #[serde(skip_serializing_if = "Option::is_none")]
3001 pub name: Option<String>,
3002 #[serde(rename = "Namespace")]
3003 #[serde(skip_serializing_if = "Option::is_none")]
3004 pub namespace: Option<String>,
3005 #[serde(rename = "NetworkSettings")]
3006 pub network_settings: Option<InspectNetworkSettings>,
3007 #[serde(rename = "OCIConfigPath")]
3008 #[serde(skip_serializing_if = "Option::is_none")]
3009 pub oci_config_path: Option<String>,
3010 #[serde(rename = "OCIRuntime")]
3011 #[serde(skip_serializing_if = "Option::is_none")]
3012 pub oci_runtime: Option<String>,
3013 #[serde(rename = "Path")]
3014 #[serde(skip_serializing_if = "Option::is_none")]
3015 pub path: Option<String>,
3016 #[serde(rename = "PidFile")]
3017 #[serde(skip_serializing_if = "Option::is_none")]
3018 pub pid_file: Option<String>,
3019 #[serde(rename = "Pod")]
3020 #[serde(skip_serializing_if = "Option::is_none")]
3021 pub pod: Option<String>,
3022 #[serde(rename = "ProcessLabel")]
3023 #[serde(skip_serializing_if = "Option::is_none")]
3024 pub process_label: Option<String>,
3025 #[serde(rename = "ResolvConfPath")]
3026 #[serde(skip_serializing_if = "Option::is_none")]
3027 pub resolv_conf_path: Option<String>,
3028 #[serde(rename = "RestartCount")]
3029 #[serde(skip_serializing_if = "Option::is_none")]
3030 pub restart_count: Option<i32>,
3031 #[serde(rename = "Rootfs")]
3032 #[serde(skip_serializing_if = "Option::is_none")]
3033 pub rootfs: Option<String>,
3034 #[serde(rename = "SizeRootFs")]
3035 #[serde(skip_serializing_if = "Option::is_none")]
3036 pub size_root_fs: Option<i64>,
3037 #[serde(rename = "SizeRw")]
3038 #[serde(skip_serializing_if = "Option::is_none")]
3039 pub size_rw: Option<i64>,
3040 #[serde(rename = "State")]
3041 pub state: Option<InspectContainerState>,
3042 #[serde(rename = "StaticDir")]
3043 #[serde(skip_serializing_if = "Option::is_none")]
3044 pub static_dir: Option<String>,
3045}
3046
3047#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3048pub struct InspectContainerHostConfig {
3050 #[serde(rename = "AutoRemove")]
3051 #[serde(skip_serializing_if = "Option::is_none")]
3052 pub auto_remove: Option<bool>,
3057 #[serde(rename = "Binds")]
3058 #[serde(skip_serializing_if = "Option::is_none")]
3059 pub binds: Option<Vec<String>>,
3067 #[serde(rename = "BlkioDeviceReadBps")]
3068 #[serde(skip_serializing_if = "Option::is_none")]
3069 pub blkio_device_read_bps: Option<Vec<InspectBlkioThrottleDevice>>,
3077 #[serde(rename = "BlkioDeviceReadIOps")]
3078 #[serde(skip_serializing_if = "Option::is_none")]
3079 pub blkio_device_read_i_ops: Option<Vec<InspectBlkioThrottleDevice>>,
3087 #[serde(rename = "BlkioDeviceWriteBps")]
3088 #[serde(skip_serializing_if = "Option::is_none")]
3089 pub blkio_device_write_bps: Option<Vec<InspectBlkioThrottleDevice>>,
3097 #[serde(rename = "BlkioDeviceWriteIOps")]
3098 #[serde(skip_serializing_if = "Option::is_none")]
3099 pub blkio_device_write_i_ops: Option<Vec<InspectBlkioThrottleDevice>>,
3107 #[serde(rename = "BlkioWeight")]
3108 #[serde(skip_serializing_if = "Option::is_none")]
3109 pub blkio_weight: Option<u16>,
3113 #[serde(rename = "BlkioWeightDevice")]
3114 #[serde(skip_serializing_if = "Option::is_none")]
3115 pub blkio_weight_device: Option<Vec<InspectBlkioWeightDevice>>,
3125 #[serde(rename = "CapAdd")]
3126 #[serde(skip_serializing_if = "Option::is_none")]
3127 pub cap_add: Option<Vec<String>>,
3132 #[serde(rename = "CapDrop")]
3133 #[serde(skip_serializing_if = "Option::is_none")]
3134 pub cap_drop: Option<Vec<String>>,
3139 #[serde(rename = "Cgroup")]
3140 #[serde(skip_serializing_if = "Option::is_none")]
3141 pub cgroup: Option<String>,
3145 #[serde(rename = "CgroupConf")]
3146 #[serde(skip_serializing_if = "Option::is_none")]
3147 pub cgroup_conf: Option<HashMap<String, String>>,
3149 #[serde(rename = "CgroupManager")]
3150 #[serde(skip_serializing_if = "Option::is_none")]
3151 pub cgroup_manager: Option<String>,
3154 #[serde(rename = "CgroupMode")]
3155 #[serde(skip_serializing_if = "Option::is_none")]
3156 pub cgroup_mode: Option<String>,
3163 #[serde(rename = "CgroupParent")]
3164 #[serde(skip_serializing_if = "Option::is_none")]
3165 pub cgroup_parent: Option<String>,
3168 #[serde(rename = "Cgroups")]
3169 #[serde(skip_serializing_if = "Option::is_none")]
3170 pub cgroups: Option<String>,
3175 #[serde(rename = "ConsoleSize")]
3176 #[serde(skip_serializing_if = "Option::is_none")]
3177 pub console_size: Option<Vec<u64>>,
3182 #[serde(rename = "ContainerIDFile")]
3183 #[serde(skip_serializing_if = "Option::is_none")]
3184 pub container_id_file: Option<String>,
3188 #[serde(rename = "CpuCount")]
3189 #[serde(skip_serializing_if = "Option::is_none")]
3190 pub cpu_count: Option<u64>,
3192 #[serde(rename = "CpuPercent")]
3193 #[serde(skip_serializing_if = "Option::is_none")]
3194 pub cpu_percent: Option<u64>,
3196 #[serde(rename = "CpuPeriod")]
3197 #[serde(skip_serializing_if = "Option::is_none")]
3198 pub cpu_period: Option<u64>,
3201 #[serde(rename = "CpuQuota")]
3202 #[serde(skip_serializing_if = "Option::is_none")]
3203 pub cpu_quota: Option<i64>,
3206 #[serde(rename = "CpuRealtimePeriod")]
3207 #[serde(skip_serializing_if = "Option::is_none")]
3208 pub cpu_realtime_period: Option<u64>,
3212 #[serde(rename = "CpuRealtimeRuntime")]
3213 #[serde(skip_serializing_if = "Option::is_none")]
3214 pub cpu_realtime_runtime: Option<i64>,
3217 #[serde(rename = "CpuShares")]
3218 #[serde(skip_serializing_if = "Option::is_none")]
3219 pub cpu_shares: Option<u64>,
3223 #[serde(rename = "CpusetCpus")]
3224 #[serde(skip_serializing_if = "Option::is_none")]
3225 pub cpuset_cpus: Option<String>,
3228 #[serde(rename = "CpusetMems")]
3229 #[serde(skip_serializing_if = "Option::is_none")]
3230 pub cpuset_mems: Option<String>,
3233 #[serde(rename = "Devices")]
3234 #[serde(skip_serializing_if = "Option::is_none")]
3235 pub devices: Option<Vec<InspectDevice>>,
3242 #[serde(rename = "DiskQuota")]
3243 #[serde(skip_serializing_if = "Option::is_none")]
3244 pub disk_quota: Option<u64>,
3249 #[serde(rename = "Dns")]
3250 #[serde(skip_serializing_if = "Option::is_none")]
3251 pub dns: Option<Vec<String>>,
3254 #[serde(rename = "DnsOptions")]
3255 #[serde(skip_serializing_if = "Option::is_none")]
3256 pub dns_options: Option<Vec<String>>,
3259 #[serde(rename = "DnsSearch")]
3260 #[serde(skip_serializing_if = "Option::is_none")]
3261 pub dns_search: Option<Vec<String>>,
3264 #[serde(rename = "ExtraHosts")]
3265 #[serde(skip_serializing_if = "Option::is_none")]
3266 pub extra_hosts: Option<Vec<String>>,
3269 #[serde(rename = "GroupAdd")]
3270 #[serde(skip_serializing_if = "Option::is_none")]
3271 pub group_add: Option<Vec<String>>,
3274 #[serde(rename = "IDMappings")]
3275 pub id_mappings: Option<InspectIdMappings>,
3276 #[serde(rename = "IOMaximumBandwidth")]
3277 #[serde(skip_serializing_if = "Option::is_none")]
3278 pub io_maximum_bandwidth: Option<u64>,
3280 #[serde(rename = "IOMaximumIOps")]
3281 #[serde(skip_serializing_if = "Option::is_none")]
3282 pub io_maximum_i_ops: Option<u64>,
3284 #[serde(rename = "Init")]
3285 #[serde(skip_serializing_if = "Option::is_none")]
3286 pub init: Option<bool>,
3288 #[serde(rename = "IpcMode")]
3289 #[serde(skip_serializing_if = "Option::is_none")]
3290 pub ipc_mode: Option<String>,
3298 #[serde(rename = "Isolation")]
3299 #[serde(skip_serializing_if = "Option::is_none")]
3300 pub isolation: Option<String>,
3303 #[serde(rename = "KernelMemory")]
3304 #[serde(skip_serializing_if = "Option::is_none")]
3305 pub kernel_memory: Option<i64>,
3308 #[serde(rename = "Links")]
3309 #[serde(skip_serializing_if = "Option::is_none")]
3310 pub links: Option<Vec<String>>,
3312 #[serde(rename = "LogConfig")]
3313 pub log_config: Option<InspectLogConfig>,
3314 #[serde(rename = "Memory")]
3315 #[serde(skip_serializing_if = "Option::is_none")]
3316 pub memory: Option<i64>,
3319 #[serde(rename = "MemoryReservation")]
3320 #[serde(skip_serializing_if = "Option::is_none")]
3321 pub memory_reservation: Option<i64>,
3324 #[serde(rename = "MemorySwap")]
3325 #[serde(skip_serializing_if = "Option::is_none")]
3326 pub memory_swap: Option<i64>,
3330 #[serde(rename = "MemorySwappiness")]
3331 #[serde(skip_serializing_if = "Option::is_none")]
3332 pub memory_swappiness: Option<i64>,
3337 #[serde(rename = "NanoCpus")]
3338 #[serde(skip_serializing_if = "Option::is_none")]
3339 pub nano_cpus: Option<i64>,
3351 #[serde(rename = "NetworkMode")]
3352 #[serde(skip_serializing_if = "Option::is_none")]
3353 pub network_mode: Option<String>,
3362 #[serde(rename = "OomKillDisable")]
3363 #[serde(skip_serializing_if = "Option::is_none")]
3364 pub oom_kill_disable: Option<bool>,
3367 #[serde(rename = "OomScoreAdj")]
3368 #[serde(skip_serializing_if = "Option::is_none")]
3369 pub oom_score_adj: Option<i64>,
3372 #[serde(rename = "PidMode")]
3373 #[serde(skip_serializing_if = "Option::is_none")]
3374 pub pid_mode: Option<String>,
3382 #[serde(rename = "PidsLimit")]
3383 #[serde(skip_serializing_if = "Option::is_none")]
3384 pub pids_limit: Option<i64>,
3387 #[serde(rename = "PortBindings")]
3388 #[serde(skip_serializing_if = "Option::is_none")]
3389 pub port_bindings: Option<HashMap<String, Option<Vec<InspectHostPort>>>>,
3395 #[serde(rename = "Privileged")]
3396 #[serde(skip_serializing_if = "Option::is_none")]
3397 pub privileged: Option<bool>,
3403 #[serde(rename = "PublishAllPorts")]
3404 #[serde(skip_serializing_if = "Option::is_none")]
3405 pub publish_all_ports: Option<bool>,
3408 #[serde(rename = "ReadonlyRootfs")]
3409 #[serde(skip_serializing_if = "Option::is_none")]
3410 pub readonly_rootfs: Option<bool>,
3412 #[serde(rename = "RestartPolicy")]
3413 pub restart_policy: Option<InspectRestartPolicy>,
3414 #[serde(rename = "Runtime")]
3415 #[serde(skip_serializing_if = "Option::is_none")]
3416 pub runtime: Option<String>,
3420 #[serde(rename = "SecurityOpt")]
3421 #[serde(skip_serializing_if = "Option::is_none")]
3422 pub security_opt: Option<Vec<String>>,
3425 #[serde(rename = "ShmSize")]
3426 #[serde(skip_serializing_if = "Option::is_none")]
3427 pub shm_size: Option<i64>,
3428 #[serde(rename = "Tmpfs")]
3429 #[serde(skip_serializing_if = "Option::is_none")]
3430 pub tmpfs: Option<HashMap<String, String>>,
3434 #[serde(rename = "UTSMode")]
3435 #[serde(skip_serializing_if = "Option::is_none")]
3436 pub uts_mode: Option<String>,
3444 #[serde(rename = "Ulimits")]
3445 #[serde(skip_serializing_if = "Option::is_none")]
3446 pub ulimits: Option<Vec<InspectUlimit>>,
3448 #[serde(rename = "UsernsMode")]
3449 #[serde(skip_serializing_if = "Option::is_none")]
3450 pub userns_mode: Option<String>,
3462 #[serde(rename = "VolumeDriver")]
3463 #[serde(skip_serializing_if = "Option::is_none")]
3464 pub volume_driver: Option<String>,
3467 #[serde(rename = "VolumesFrom")]
3468 #[serde(skip_serializing_if = "Option::is_none")]
3469 pub volumes_from: Option<Vec<String>>,
3474}
3475
3476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3477pub struct InspectContainerState {
3483 #[serde(rename = "CgroupPath")]
3484 #[serde(skip_serializing_if = "Option::is_none")]
3485 pub cgroup_path: Option<String>,
3486 #[serde(rename = "CheckpointLog")]
3487 #[serde(skip_serializing_if = "Option::is_none")]
3488 pub checkpoint_log: Option<String>,
3489 #[serde(rename = "CheckpointPath")]
3490 #[serde(skip_serializing_if = "Option::is_none")]
3491 pub checkpoint_path: Option<String>,
3492 #[serde(rename = "Checkpointed")]
3493 #[serde(skip_serializing_if = "Option::is_none")]
3494 pub checkpointed: Option<bool>,
3495 #[serde(rename = "CheckpointedAt")]
3496 #[serde(skip_serializing_if = "Option::is_none")]
3497 pub checkpointed_at: Option<DateTime<Utc>>,
3498 #[serde(rename = "ConmonPid")]
3499 #[serde(skip_serializing_if = "Option::is_none")]
3500 pub conmon_pid: Option<i64>,
3501 #[serde(rename = "Dead")]
3502 #[serde(skip_serializing_if = "Option::is_none")]
3503 pub dead: Option<bool>,
3504 #[serde(rename = "Error")]
3505 #[serde(skip_serializing_if = "Option::is_none")]
3506 pub error: Option<String>,
3507 #[serde(rename = "ExitCode")]
3508 #[serde(skip_serializing_if = "Option::is_none")]
3509 pub exit_code: Option<i32>,
3510 #[serde(rename = "FinishedAt")]
3511 #[serde(skip_serializing_if = "Option::is_none")]
3512 pub finished_at: Option<DateTime<Utc>>,
3513 #[serde(rename = "Health")]
3514 pub health: Option<HealthCheckResults>,
3515 #[serde(rename = "OOMKilled")]
3516 #[serde(skip_serializing_if = "Option::is_none")]
3517 pub oom_killed: Option<bool>,
3518 #[serde(rename = "OciVersion")]
3519 #[serde(skip_serializing_if = "Option::is_none")]
3520 pub oci_version: Option<String>,
3521 #[serde(rename = "Paused")]
3522 #[serde(skip_serializing_if = "Option::is_none")]
3523 pub paused: Option<bool>,
3524 #[serde(rename = "Pid")]
3525 #[serde(skip_serializing_if = "Option::is_none")]
3526 pub pid: Option<i64>,
3527 #[serde(rename = "Restarting")]
3528 #[serde(skip_serializing_if = "Option::is_none")]
3529 pub restarting: Option<bool>,
3530 #[serde(rename = "RestoreLog")]
3531 #[serde(skip_serializing_if = "Option::is_none")]
3532 pub restore_log: Option<String>,
3533 #[serde(rename = "Restored")]
3534 #[serde(skip_serializing_if = "Option::is_none")]
3535 pub restored: Option<bool>,
3536 #[serde(rename = "RestoredAt")]
3537 #[serde(skip_serializing_if = "Option::is_none")]
3538 pub restored_at: Option<DateTime<Utc>>,
3539 #[serde(rename = "Running")]
3540 #[serde(skip_serializing_if = "Option::is_none")]
3541 pub running: Option<bool>,
3542 #[serde(rename = "StartedAt")]
3543 #[serde(skip_serializing_if = "Option::is_none")]
3544 pub started_at: Option<DateTime<Utc>>,
3545 #[serde(rename = "Status")]
3546 #[serde(skip_serializing_if = "Option::is_none")]
3547 pub status: Option<String>,
3548}
3549
3550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3551pub struct InspectDevice {
3552 #[serde(rename = "CgroupPermissions")]
3553 #[serde(skip_serializing_if = "Option::is_none")]
3554 pub cgroup_permissions: Option<String>,
3558 #[serde(rename = "PathInContainer")]
3559 #[serde(skip_serializing_if = "Option::is_none")]
3560 pub path_in_container: Option<String>,
3562 #[serde(rename = "PathOnHost")]
3563 #[serde(skip_serializing_if = "Option::is_none")]
3564 pub path_on_host: Option<String>,
3566}
3567
3568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3569pub struct InspectExecProcess {
3572 #[serde(skip_serializing_if = "Option::is_none")]
3573 pub arguments: Option<Vec<String>>,
3576 #[serde(skip_serializing_if = "Option::is_none")]
3577 pub entrypoint: Option<String>,
3580 #[serde(skip_serializing_if = "Option::is_none")]
3581 pub privileged: Option<bool>,
3584 #[serde(skip_serializing_if = "Option::is_none")]
3585 pub tty: Option<bool>,
3587 #[serde(skip_serializing_if = "Option::is_none")]
3588 pub user: Option<String>,
3590}
3591
3592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3593pub struct InspectExecSession {
3594 #[serde(rename = "CanRemove")]
3595 #[serde(skip_serializing_if = "Option::is_none")]
3596 pub can_remove: Option<bool>,
3599 #[serde(rename = "ContainerID")]
3600 #[serde(skip_serializing_if = "Option::is_none")]
3601 pub container_id: Option<String>,
3604 #[serde(rename = "DetachKeys")]
3605 #[serde(skip_serializing_if = "Option::is_none")]
3606 pub detach_keys: Option<String>,
3610 #[serde(rename = "ExitCode")]
3611 #[serde(skip_serializing_if = "Option::is_none")]
3612 pub exit_code: Option<i64>,
3615 #[serde(rename = "ID")]
3616 #[serde(skip_serializing_if = "Option::is_none")]
3617 pub id: Option<String>,
3619 #[serde(rename = "OpenStderr")]
3620 #[serde(skip_serializing_if = "Option::is_none")]
3621 pub open_stderr: Option<bool>,
3624 #[serde(rename = "OpenStdin")]
3625 #[serde(skip_serializing_if = "Option::is_none")]
3626 pub open_stdin: Option<bool>,
3629 #[serde(rename = "OpenStdout")]
3630 #[serde(skip_serializing_if = "Option::is_none")]
3631 pub open_stdout: Option<bool>,
3634 #[serde(rename = "Pid")]
3635 #[serde(skip_serializing_if = "Option::is_none")]
3636 pub pid: Option<i64>,
3639 #[serde(rename = "ProcessConfig")]
3640 pub process_config: Option<InspectExecProcess>,
3641 #[serde(rename = "Running")]
3642 #[serde(skip_serializing_if = "Option::is_none")]
3643 pub running: Option<bool>,
3645}
3646
3647#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3648pub struct InspectHostPort {
3651 #[serde(rename = "HostIp")]
3652 #[serde(skip_serializing_if = "Option::is_none")]
3653 pub host_ip: Option<String>,
3656 #[serde(rename = "HostPort")]
3657 #[serde(skip_serializing_if = "Option::is_none")]
3658 pub host_port: Option<String>,
3661}
3662
3663#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3664pub struct InspectIdMappings {
3665 #[serde(rename = "GidMap")]
3666 #[serde(skip_serializing_if = "Option::is_none")]
3667 pub gid_map: Option<Vec<String>>,
3668 #[serde(rename = "UidMap")]
3669 #[serde(skip_serializing_if = "Option::is_none")]
3670 pub uid_map: Option<Vec<String>>,
3671}
3672
3673#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3674pub struct InspectLogConfig {
3676 #[serde(rename = "Config")]
3677 #[serde(skip_serializing_if = "Option::is_none")]
3678 pub config: Option<HashMap<String, String>>,
3679 #[serde(rename = "Path")]
3680 #[serde(skip_serializing_if = "Option::is_none")]
3681 pub path: Option<String>,
3683 #[serde(rename = "Size")]
3684 #[serde(skip_serializing_if = "Option::is_none")]
3685 pub size: Option<String>,
3687 #[serde(rename = "Tag")]
3688 #[serde(skip_serializing_if = "Option::is_none")]
3689 pub tag: Option<String>,
3691 #[serde(rename = "Type")]
3692 #[serde(skip_serializing_if = "Option::is_none")]
3693 pub type_: Option<String>,
3694}
3695
3696#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3697pub struct InspectMount {
3701 #[serde(rename = "Destination")]
3702 #[serde(skip_serializing_if = "Option::is_none")]
3703 pub destination: Option<String>,
3706 #[serde(rename = "Driver")]
3707 #[serde(skip_serializing_if = "Option::is_none")]
3708 pub driver: Option<String>,
3710 #[serde(rename = "Mode")]
3711 #[serde(skip_serializing_if = "Option::is_none")]
3712 pub mode: Option<String>,
3715 #[serde(rename = "Name")]
3716 #[serde(skip_serializing_if = "Option::is_none")]
3717 pub name: Option<String>,
3719 #[serde(rename = "Options")]
3720 #[serde(skip_serializing_if = "Option::is_none")]
3721 pub options: Option<Vec<String>>,
3724 #[serde(rename = "Propagation")]
3725 #[serde(skip_serializing_if = "Option::is_none")]
3726 pub propagation: Option<String>,
3729 #[serde(rename = "RW")]
3730 #[serde(skip_serializing_if = "Option::is_none")]
3731 pub rw: Option<bool>,
3733 #[serde(rename = "Source")]
3734 #[serde(skip_serializing_if = "Option::is_none")]
3735 pub source: Option<String>,
3737 #[serde(rename = "Type")]
3738 #[serde(skip_serializing_if = "Option::is_none")]
3739 pub type_: Option<String>,
3742}
3743
3744#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3745pub struct InspectNetworkSettings {
3750 #[serde(rename = "AdditionalMACAddresses")]
3751 #[serde(skip_serializing_if = "Option::is_none")]
3752 pub additional_mac_addresses: Option<Vec<String>>,
3756 #[serde(rename = "Bridge")]
3757 #[serde(skip_serializing_if = "Option::is_none")]
3758 pub bridge: Option<String>,
3759 #[serde(rename = "EndpointID")]
3760 #[serde(skip_serializing_if = "Option::is_none")]
3761 pub endpoint_id: Option<String>,
3763 #[serde(rename = "Gateway")]
3764 #[serde(skip_serializing_if = "Option::is_none")]
3765 pub gateway: Option<String>,
3767 #[serde(rename = "GlobalIPv6Address")]
3768 #[serde(skip_serializing_if = "Option::is_none")]
3769 pub global_i_pv_6_address: Option<String>,
3771 #[serde(rename = "GlobalIPv6PrefixLen")]
3772 #[serde(skip_serializing_if = "Option::is_none")]
3773 pub global_i_pv_6_prefix_len: Option<i64>,
3775 #[serde(rename = "HairpinMode")]
3776 #[serde(skip_serializing_if = "Option::is_none")]
3777 pub hairpin_mode: Option<bool>,
3778 #[serde(rename = "IPAddress")]
3779 #[serde(skip_serializing_if = "Option::is_none")]
3780 pub ip_address: Option<String>,
3782 #[serde(rename = "IPPrefixLen")]
3783 #[serde(skip_serializing_if = "Option::is_none")]
3784 pub ip_prefix_len: Option<i64>,
3786 #[serde(rename = "IPv6Gateway")]
3787 #[serde(skip_serializing_if = "Option::is_none")]
3788 pub i_pv_6_gateway: Option<String>,
3790 #[serde(rename = "LinkLocalIPv6Address")]
3791 #[serde(skip_serializing_if = "Option::is_none")]
3792 pub link_local_i_pv_6_address: Option<String>,
3793 #[serde(rename = "LinkLocalIPv6PrefixLen")]
3794 #[serde(skip_serializing_if = "Option::is_none")]
3795 pub link_local_i_pv_6_prefix_len: Option<i64>,
3796 #[serde(rename = "MacAddress")]
3797 #[serde(skip_serializing_if = "Option::is_none")]
3798 pub mac_address: Option<String>,
3800 #[serde(rename = "Networks")]
3801 #[serde(skip_serializing_if = "Option::is_none")]
3802 pub networks: Option<HashMap<String, InspectAdditionalNetwork>>,
3806 #[serde(rename = "Ports")]
3807 #[serde(skip_serializing_if = "Option::is_none")]
3808 pub ports: Option<HashMap<String, Option<Vec<InspectHostPort>>>>,
3809 #[serde(rename = "SandboxID")]
3810 #[serde(skip_serializing_if = "Option::is_none")]
3811 pub sandbox_id: Option<String>,
3812 #[serde(rename = "SandboxKey")]
3813 #[serde(skip_serializing_if = "Option::is_none")]
3814 pub sandbox_key: Option<String>,
3815 #[serde(rename = "SecondaryIPAddresses")]
3816 #[serde(skip_serializing_if = "Option::is_none")]
3817 pub secondary_ip_addresses: Option<Vec<Address>>,
3820 #[serde(rename = "SecondaryIPv6Addresses")]
3821 #[serde(skip_serializing_if = "Option::is_none")]
3822 pub secondary_i_pv_6_addresses: Option<Vec<Address>>,
3825}
3826
3827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3828pub struct InspectPodContainerInfo {
3829 #[serde(rename = "Id")]
3830 #[serde(skip_serializing_if = "Option::is_none")]
3831 pub id: Option<String>,
3833 #[serde(rename = "Name")]
3834 #[serde(skip_serializing_if = "Option::is_none")]
3835 pub name: Option<String>,
3837 #[serde(rename = "State")]
3838 #[serde(skip_serializing_if = "Option::is_none")]
3839 pub state: Option<String>,
3841}
3842
3843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3844pub struct InspectPodData {
3847 #[serde(rename = "CgroupParent")]
3848 #[serde(skip_serializing_if = "Option::is_none")]
3849 pub cgroup_parent: Option<String>,
3851 #[serde(rename = "CgroupPath")]
3852 #[serde(skip_serializing_if = "Option::is_none")]
3853 pub cgroup_path: Option<String>,
3855 #[serde(rename = "Containers")]
3856 #[serde(skip_serializing_if = "Option::is_none")]
3857 pub containers: Option<Vec<InspectPodContainerInfo>>,
3860 #[serde(rename = "CreateCgroup")]
3861 #[serde(skip_serializing_if = "Option::is_none")]
3862 pub create_cgroup: Option<bool>,
3865 #[serde(rename = "CreateCommand")]
3866 #[serde(skip_serializing_if = "Option::is_none")]
3867 pub create_command: Option<Vec<String>>,
3870 #[serde(rename = "CreateInfra")]
3871 #[serde(skip_serializing_if = "Option::is_none")]
3872 pub create_infra: Option<bool>,
3875 #[serde(rename = "Created")]
3876 #[serde(skip_serializing_if = "Option::is_none")]
3877 pub created: Option<DateTime<Utc>>,
3879 #[serde(rename = "ExitPolicy")]
3880 #[serde(skip_serializing_if = "Option::is_none")]
3881 pub exit_policy: Option<String>,
3883 #[serde(rename = "Hostname")]
3884 #[serde(skip_serializing_if = "Option::is_none")]
3885 pub hostname: Option<String>,
3887 #[serde(rename = "Id")]
3888 #[serde(skip_serializing_if = "Option::is_none")]
3889 pub id: Option<String>,
3891 #[serde(rename = "InfraConfig")]
3892 pub infra_config: Option<InspectPodInfraConfig>,
3893 #[serde(rename = "InfraContainerID")]
3894 #[serde(skip_serializing_if = "Option::is_none")]
3895 pub infra_container_id: Option<String>,
3898 #[serde(rename = "Labels")]
3899 #[serde(skip_serializing_if = "Option::is_none")]
3900 pub labels: Option<HashMap<String, String>>,
3903 #[serde(rename = "Name")]
3904 #[serde(skip_serializing_if = "Option::is_none")]
3905 pub name: Option<String>,
3907 #[serde(rename = "Namespace")]
3908 #[serde(skip_serializing_if = "Option::is_none")]
3909 pub namespace: Option<String>,
3911 #[serde(rename = "NumContainers")]
3912 #[serde(skip_serializing_if = "Option::is_none")]
3913 pub num_containers: Option<u64>,
3916 #[serde(rename = "SharedNamespaces")]
3917 #[serde(skip_serializing_if = "Option::is_none")]
3918 pub shared_namespaces: Option<Vec<String>>,
3921 #[serde(rename = "State")]
3922 #[serde(skip_serializing_if = "Option::is_none")]
3923 pub state: Option<String>,
3925 #[serde(skip_serializing_if = "Option::is_none")]
3926 pub blkio_weight: Option<u64>,
3928 #[serde(skip_serializing_if = "Option::is_none")]
3929 pub blkio_weight_device: Option<Vec<InspectBlkioWeightDevice>>,
3931 #[serde(skip_serializing_if = "Option::is_none")]
3932 pub cpu_period: Option<u64>,
3934 #[serde(skip_serializing_if = "Option::is_none")]
3935 pub cpu_quota: Option<i64>,
3937 #[serde(skip_serializing_if = "Option::is_none")]
3938 pub cpu_shares: Option<u64>,
3940 #[serde(skip_serializing_if = "Option::is_none")]
3941 pub cpuset_cpus: Option<String>,
3943 #[serde(skip_serializing_if = "Option::is_none")]
3944 pub cpuset_mems: Option<String>,
3946 #[serde(skip_serializing_if = "Option::is_none")]
3947 pub device_read_bps: Option<Vec<InspectBlkioThrottleDevice>>,
3949 #[serde(skip_serializing_if = "Option::is_none")]
3950 pub device_write_bps: Option<Vec<InspectBlkioThrottleDevice>>,
3952 #[serde(skip_serializing_if = "Option::is_none")]
3953 pub devices: Option<Vec<InspectDevice>>,
3955 #[serde(skip_serializing_if = "Option::is_none")]
3956 pub memory_limit: Option<u64>,
3958 #[serde(skip_serializing_if = "Option::is_none")]
3959 pub memory_swap: Option<u64>,
3961 #[serde(skip_serializing_if = "Option::is_none")]
3962 pub mounts: Option<Vec<InspectMount>>,
3964 #[serde(skip_serializing_if = "Option::is_none")]
3965 pub security_opt: Option<Vec<String>>,
3967 #[serde(skip_serializing_if = "Option::is_none")]
3968 pub volumes_from: Option<Vec<String>>,
3970}
3971
3972#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3973pub struct InspectPodInfraConfig {
3976 #[serde(rename = "DNSOption")]
3977 #[serde(skip_serializing_if = "Option::is_none")]
3978 pub dns_option: Option<Vec<String>>,
3981 #[serde(rename = "DNSSearch")]
3982 #[serde(skip_serializing_if = "Option::is_none")]
3983 pub dns_search: Option<Vec<String>>,
3987 #[serde(rename = "DNSServer")]
3988 #[serde(skip_serializing_if = "Option::is_none")]
3989 pub dns_server: Option<Vec<String>>,
3992 #[serde(rename = "HostAdd")]
3993 #[serde(skip_serializing_if = "Option::is_none")]
3994 pub host_add: Option<Vec<String>>,
3997 #[serde(rename = "HostNetwork")]
3998 #[serde(skip_serializing_if = "Option::is_none")]
3999 pub host_network: Option<bool>,
4002 #[serde(rename = "NetworkOptions")]
4003 #[serde(skip_serializing_if = "Option::is_none")]
4004 pub network_options: Option<HashMap<String, Vec<String>>>,
4006 #[serde(rename = "Networks")]
4007 #[serde(skip_serializing_if = "Option::is_none")]
4008 pub networks: Option<Vec<String>>,
4010 #[serde(rename = "NoManageHosts")]
4011 #[serde(skip_serializing_if = "Option::is_none")]
4012 pub no_manage_hosts: Option<bool>,
4015 #[serde(rename = "NoManageResolvConf")]
4016 #[serde(skip_serializing_if = "Option::is_none")]
4017 pub no_manage_resolv_conf: Option<bool>,
4020 #[serde(rename = "PortBindings")]
4021 #[serde(skip_serializing_if = "Option::is_none")]
4022 pub port_bindings: Option<HashMap<String, Option<Vec<InspectHostPort>>>>,
4025 #[serde(rename = "StaticIP")]
4026 #[serde(skip_serializing_if = "Option::is_none")]
4027 pub static_ip: Option<String>,
4030 #[serde(rename = "StaticMAC")]
4031 #[serde(skip_serializing_if = "Option::is_none")]
4032 pub static_mac: Option<String>,
4035 #[serde(skip_serializing_if = "Option::is_none")]
4036 pub cpu_period: Option<u64>,
4038 #[serde(skip_serializing_if = "Option::is_none")]
4039 pub cpu_quota: Option<i64>,
4041 #[serde(skip_serializing_if = "Option::is_none")]
4042 pub cpuset_cpus: Option<String>,
4044 #[serde(skip_serializing_if = "Option::is_none")]
4045 pub pid_ns: Option<String>,
4047 #[serde(skip_serializing_if = "Option::is_none")]
4048 pub userns: Option<String>,
4050 #[serde(skip_serializing_if = "Option::is_none")]
4051 pub uts_ns: Option<String>,
4053}
4054
4055#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4056pub struct InspectRestartPolicy {
4057 #[serde(rename = "MaximumRetryCount")]
4058 #[serde(skip_serializing_if = "Option::is_none")]
4059 pub maximum_retry_count: Option<u64>,
4063 #[serde(rename = "Name")]
4064 #[serde(skip_serializing_if = "Option::is_none")]
4065 pub name: Option<String>,
4073}
4074
4075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4076pub struct InspectSecret {
4078 #[serde(rename = "GID")]
4079 #[serde(skip_serializing_if = "Option::is_none")]
4080 pub gid: Option<u32>,
4082 #[serde(rename = "ID")]
4083 #[serde(skip_serializing_if = "Option::is_none")]
4084 pub id: Option<String>,
4086 #[serde(rename = "Mode")]
4087 #[serde(skip_serializing_if = "Option::is_none")]
4088 pub mode: Option<u32>,
4090 #[serde(rename = "Name")]
4091 #[serde(skip_serializing_if = "Option::is_none")]
4092 pub name: Option<String>,
4094 #[serde(rename = "UID")]
4095 #[serde(skip_serializing_if = "Option::is_none")]
4096 pub uid: Option<u32>,
4098}
4099
4100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4101pub struct InspectUlimit {
4102 #[serde(rename = "Hard")]
4103 #[serde(skip_serializing_if = "Option::is_none")]
4104 pub hard: Option<i64>,
4106 #[serde(rename = "Name")]
4107 #[serde(skip_serializing_if = "Option::is_none")]
4108 pub name: Option<String>,
4110 #[serde(rename = "Soft")]
4111 #[serde(skip_serializing_if = "Option::is_none")]
4112 pub soft: Option<i64>,
4114}
4115
4116pub type IpcMode = String;
4117
4118pub type Isolation = String;
4121
4122pub type KubeApplyLibpod200Response = Vec<u8>;
4124
4125pub type KubeApplyLibpodRequestParam = String;
4126
4127#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4128pub struct LeaseRange {
4129 #[serde(skip_serializing_if = "Option::is_none")]
4130 pub end_ip: Option<String>,
4132 #[serde(skip_serializing_if = "Option::is_none")]
4133 pub start_ip: Option<String>,
4135}
4136
4137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4138pub struct LibpodContainersRmReport {
4139 #[serde(rename = "Err")]
4140 #[serde(skip_serializing_if = "Option::is_none")]
4141 pub err: Option<String>,
4144 #[serde(rename = "Id")]
4145 #[serde(skip_serializing_if = "Option::is_none")]
4146 pub id: Option<String>,
4147}
4148
4149#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4150pub struct LibpodImageSummary {
4151 #[serde(rename = "Containers")]
4152 #[serde(skip_serializing_if = "Option::is_none")]
4153 pub containers: Option<i64>,
4154 #[serde(rename = "Created")]
4155 #[serde(skip_serializing_if = "Option::is_none")]
4156 pub created: Option<i64>,
4157 #[serde(rename = "Dangling")]
4158 #[serde(skip_serializing_if = "Option::is_none")]
4159 pub dangling: Option<bool>,
4160 #[serde(rename = "Digest")]
4161 #[serde(skip_serializing_if = "Option::is_none")]
4162 pub digest: Option<String>,
4163 #[serde(rename = "History")]
4164 #[serde(skip_serializing_if = "Option::is_none")]
4165 pub history: Option<Vec<String>>,
4166 #[serde(rename = "Id")]
4167 #[serde(skip_serializing_if = "Option::is_none")]
4168 pub id: Option<String>,
4169 #[serde(rename = "Labels")]
4170 #[serde(skip_serializing_if = "Option::is_none")]
4171 pub labels: Option<HashMap<String, String>>,
4172 #[serde(rename = "Names")]
4173 #[serde(skip_serializing_if = "Option::is_none")]
4174 pub names: Option<Vec<String>>,
4176 #[serde(rename = "ParentId")]
4177 #[serde(skip_serializing_if = "Option::is_none")]
4178 pub parent_id: Option<String>,
4179 #[serde(rename = "ReadOnly")]
4180 #[serde(skip_serializing_if = "Option::is_none")]
4181 pub read_only: Option<bool>,
4182 #[serde(rename = "RepoDigests")]
4183 #[serde(skip_serializing_if = "Option::is_none")]
4184 pub repo_digests: Option<Vec<String>>,
4185 #[serde(rename = "RepoTags")]
4186 #[serde(skip_serializing_if = "Option::is_none")]
4187 pub repo_tags: Option<Vec<String>>,
4188 #[serde(rename = "SharedSize")]
4189 #[serde(skip_serializing_if = "Option::is_none")]
4190 pub shared_size: Option<i64>,
4191 #[serde(rename = "Size")]
4192 #[serde(skip_serializing_if = "Option::is_none")]
4193 pub size: Option<i64>,
4194 #[serde(rename = "VirtualSize")]
4195 #[serde(skip_serializing_if = "Option::is_none")]
4196 pub virtual_size: Option<i64>,
4197}
4198
4199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4200pub struct LibpodImagesPullReport {
4201 #[serde(skip_serializing_if = "Option::is_none")]
4202 pub error: Option<String>,
4204 #[serde(skip_serializing_if = "Option::is_none")]
4205 pub id: Option<String>,
4207 #[serde(skip_serializing_if = "Option::is_none")]
4208 pub images: Option<Vec<String>>,
4210 #[serde(skip_serializing_if = "Option::is_none")]
4211 pub stream: Option<String>,
4213}
4214
4215#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4216pub struct LibpodImagesRemoveReport {
4219 #[serde(rename = "Deleted")]
4220 #[serde(skip_serializing_if = "Option::is_none")]
4221 pub deleted: Option<Vec<String>>,
4223 #[serde(rename = "Errors")]
4224 #[serde(skip_serializing_if = "Option::is_none")]
4225 pub errors: Option<Vec<String>>,
4227 #[serde(rename = "ExitCode")]
4228 #[serde(skip_serializing_if = "Option::is_none")]
4229 pub exit_code: Option<i64>,
4232 #[serde(rename = "Untagged")]
4233 #[serde(skip_serializing_if = "Option::is_none")]
4234 pub untagged: Option<Vec<String>>,
4236}
4237
4238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4239pub struct LinuxBlockIo {
4241 #[serde(rename = "leafWeight")]
4242 #[serde(skip_serializing_if = "Option::is_none")]
4243 pub leaf_weight: Option<u16>,
4245 #[serde(rename = "throttleReadBpsDevice")]
4246 #[serde(skip_serializing_if = "Option::is_none")]
4247 pub throttle_read_bps_device: Option<Vec<LinuxThrottleDevice>>,
4249 #[serde(rename = "throttleReadIOPSDevice")]
4250 #[serde(skip_serializing_if = "Option::is_none")]
4251 pub throttle_read_iops_device: Option<Vec<LinuxThrottleDevice>>,
4253 #[serde(rename = "throttleWriteBpsDevice")]
4254 #[serde(skip_serializing_if = "Option::is_none")]
4255 pub throttle_write_bps_device: Option<Vec<LinuxThrottleDevice>>,
4257 #[serde(rename = "throttleWriteIOPSDevice")]
4258 #[serde(skip_serializing_if = "Option::is_none")]
4259 pub throttle_write_iops_device: Option<Vec<LinuxThrottleDevice>>,
4261 #[serde(skip_serializing_if = "Option::is_none")]
4262 pub weight: Option<u16>,
4264 #[serde(rename = "weightDevice")]
4265 #[serde(skip_serializing_if = "Option::is_none")]
4266 pub weight_device: Option<Vec<LinuxWeightDevice>>,
4268}
4269
4270#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4271pub struct LinuxBlockIoDevice {
4273 #[serde(skip_serializing_if = "Option::is_none")]
4274 pub major: Option<i64>,
4276 #[serde(skip_serializing_if = "Option::is_none")]
4277 pub minor: Option<i64>,
4279}
4280
4281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4282pub struct LinuxCpu {
4284 #[serde(skip_serializing_if = "Option::is_none")]
4285 pub burst: Option<u64>,
4288 #[serde(skip_serializing_if = "Option::is_none")]
4289 pub cpus: Option<String>,
4291 #[serde(skip_serializing_if = "Option::is_none")]
4292 pub idle: Option<i64>,
4294 #[serde(skip_serializing_if = "Option::is_none")]
4295 pub mems: Option<String>,
4297 #[serde(skip_serializing_if = "Option::is_none")]
4298 pub period: Option<u64>,
4300 #[serde(skip_serializing_if = "Option::is_none")]
4301 pub quota: Option<i64>,
4303 #[serde(rename = "realtimePeriod")]
4304 #[serde(skip_serializing_if = "Option::is_none")]
4305 pub realtime_period: Option<u64>,
4307 #[serde(rename = "realtimeRuntime")]
4308 #[serde(skip_serializing_if = "Option::is_none")]
4309 pub realtime_runtime: Option<i64>,
4311 #[serde(skip_serializing_if = "Option::is_none")]
4312 pub shares: Option<u64>,
4314}
4315
4316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4317pub struct LinuxDevice {
4319 #[serde(rename = "fileMode")]
4320 pub file_mode: Option<u32>,
4321 #[serde(skip_serializing_if = "Option::is_none")]
4322 pub gid: Option<u32>,
4324 #[serde(skip_serializing_if = "Option::is_none")]
4325 pub major: Option<i64>,
4327 #[serde(skip_serializing_if = "Option::is_none")]
4328 pub minor: Option<i64>,
4330 #[serde(skip_serializing_if = "Option::is_none")]
4331 pub path: Option<String>,
4333 #[serde(rename = "type")]
4334 #[serde(skip_serializing_if = "Option::is_none")]
4335 pub type_: Option<String>,
4337 #[serde(skip_serializing_if = "Option::is_none")]
4338 pub uid: Option<u32>,
4340}
4341
4342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4343pub struct LinuxDeviceCgroup {
4346 #[serde(skip_serializing_if = "Option::is_none")]
4347 pub access: Option<String>,
4349 #[serde(skip_serializing_if = "Option::is_none")]
4350 pub allow: Option<bool>,
4352 #[serde(skip_serializing_if = "Option::is_none")]
4353 pub major: Option<i64>,
4355 #[serde(skip_serializing_if = "Option::is_none")]
4356 pub minor: Option<i64>,
4358 #[serde(rename = "type")]
4359 #[serde(skip_serializing_if = "Option::is_none")]
4360 pub type_: Option<String>,
4362}
4363
4364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4365pub struct LinuxHugepageLimit {
4367 #[serde(skip_serializing_if = "Option::is_none")]
4368 pub limit: Option<u64>,
4370 #[serde(rename = "pageSize")]
4371 #[serde(skip_serializing_if = "Option::is_none")]
4372 pub page_size: Option<String>,
4375}
4376
4377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4378pub struct LinuxIdMapping {
4380 #[serde(rename = "containerID")]
4381 #[serde(skip_serializing_if = "Option::is_none")]
4382 pub container_id: Option<u32>,
4384 #[serde(rename = "hostID")]
4385 #[serde(skip_serializing_if = "Option::is_none")]
4386 pub host_id: Option<u32>,
4388 #[serde(skip_serializing_if = "Option::is_none")]
4389 pub size: Option<u32>,
4391}
4392
4393#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4394pub struct LinuxInterfacePriority {
4396 #[serde(skip_serializing_if = "Option::is_none")]
4397 pub name: Option<String>,
4399 #[serde(skip_serializing_if = "Option::is_none")]
4400 pub priority: Option<u32>,
4402}
4403
4404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4405pub struct LinuxMemory {
4407 #[serde(rename = "checkBeforeUpdate")]
4408 #[serde(skip_serializing_if = "Option::is_none")]
4409 pub check_before_update: Option<bool>,
4413 #[serde(rename = "disableOOMKiller")]
4414 #[serde(skip_serializing_if = "Option::is_none")]
4415 pub disable_oom_killer: Option<bool>,
4417 #[serde(skip_serializing_if = "Option::is_none")]
4418 pub kernel: Option<i64>,
4420 #[serde(rename = "kernelTCP")]
4421 #[serde(skip_serializing_if = "Option::is_none")]
4422 pub kernel_tcp: Option<i64>,
4424 #[serde(skip_serializing_if = "Option::is_none")]
4425 pub limit: Option<i64>,
4427 #[serde(skip_serializing_if = "Option::is_none")]
4428 pub reservation: Option<i64>,
4430 #[serde(skip_serializing_if = "Option::is_none")]
4431 pub swap: Option<i64>,
4433 #[serde(skip_serializing_if = "Option::is_none")]
4434 pub swappiness: Option<u64>,
4436 #[serde(rename = "useHierarchy")]
4437 #[serde(skip_serializing_if = "Option::is_none")]
4438 pub use_hierarchy: Option<bool>,
4440}
4441
4442#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4443pub struct LinuxNetwork {
4445 #[serde(rename = "classID")]
4446 #[serde(skip_serializing_if = "Option::is_none")]
4447 pub class_id: Option<u32>,
4449 #[serde(skip_serializing_if = "Option::is_none")]
4450 pub priorities: Option<Vec<LinuxInterfacePriority>>,
4452}
4453
4454#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4455pub struct LinuxPersonality {
4457 pub domain: Option<String>,
4458 #[serde(skip_serializing_if = "Option::is_none")]
4459 pub flags: Option<Vec<String>>,
4461}
4462
4463pub type LinuxPersonalityDomain = String;
4464
4465pub type LinuxPersonalityFlag = String;
4466
4467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4468pub struct LinuxPids {
4470 #[serde(skip_serializing_if = "Option::is_none")]
4471 pub limit: Option<i64>,
4473}
4474
4475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4476pub struct LinuxRdma {
4478 #[serde(rename = "hcaHandles")]
4479 #[serde(skip_serializing_if = "Option::is_none")]
4480 pub hca_handles: Option<u32>,
4482 #[serde(rename = "hcaObjects")]
4483 #[serde(skip_serializing_if = "Option::is_none")]
4484 pub hca_objects: Option<u32>,
4486}
4487
4488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4489pub struct LinuxResources {
4491 #[serde(rename = "blockIO")]
4492 pub block_io: Option<LinuxBlockIo>,
4493 pub cpu: Option<LinuxCpu>,
4494 #[serde(skip_serializing_if = "Option::is_none")]
4495 pub devices: Option<Vec<LinuxDeviceCgroup>>,
4497 #[serde(rename = "hugepageLimits")]
4498 #[serde(skip_serializing_if = "Option::is_none")]
4499 pub hugepage_limits: Option<Vec<LinuxHugepageLimit>>,
4501 pub memory: Option<LinuxMemory>,
4502 pub network: Option<LinuxNetwork>,
4503 pub pids: Option<LinuxPids>,
4504 #[serde(skip_serializing_if = "Option::is_none")]
4505 pub rdma: Option<HashMap<String, LinuxRdma>>,
4509 #[serde(skip_serializing_if = "Option::is_none")]
4510 pub unified: Option<HashMap<String, String>>,
4512}
4513
4514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4515pub struct LinuxThrottleDevice {
4517 #[serde(skip_serializing_if = "Option::is_none")]
4518 pub major: Option<i64>,
4520 #[serde(skip_serializing_if = "Option::is_none")]
4521 pub minor: Option<i64>,
4523 #[serde(skip_serializing_if = "Option::is_none")]
4524 pub rate: Option<u64>,
4526}
4527
4528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4529pub struct LinuxWeightDevice {
4531 #[serde(rename = "leafWeight")]
4532 #[serde(skip_serializing_if = "Option::is_none")]
4533 pub leaf_weight: Option<u16>,
4535 #[serde(skip_serializing_if = "Option::is_none")]
4536 pub major: Option<i64>,
4538 #[serde(skip_serializing_if = "Option::is_none")]
4539 pub minor: Option<i64>,
4541 #[serde(skip_serializing_if = "Option::is_none")]
4542 pub weight: Option<u16>,
4544}
4545
4546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4547pub struct ListContainer {
4549 #[serde(rename = "AutoRemove")]
4550 #[serde(skip_serializing_if = "Option::is_none")]
4551 pub auto_remove: Option<bool>,
4553 #[serde(rename = "Command")]
4554 #[serde(skip_serializing_if = "Option::is_none")]
4555 pub command: Option<Vec<String>>,
4557 #[serde(rename = "Created")]
4558 #[serde(skip_serializing_if = "Option::is_none")]
4559 pub created: Option<DateTime<Utc>>,
4561 #[serde(rename = "CreatedAt")]
4562 #[serde(skip_serializing_if = "Option::is_none")]
4563 pub created_at: Option<String>,
4565 #[serde(rename = "ExitCode")]
4566 #[serde(skip_serializing_if = "Option::is_none")]
4567 pub exit_code: Option<i32>,
4569 #[serde(rename = "Exited")]
4570 #[serde(skip_serializing_if = "Option::is_none")]
4571 pub exited: Option<bool>,
4573 #[serde(rename = "ExitedAt")]
4574 #[serde(skip_serializing_if = "Option::is_none")]
4575 pub exited_at: Option<i64>,
4577 #[serde(rename = "Id")]
4578 #[serde(skip_serializing_if = "Option::is_none")]
4579 pub id: Option<String>,
4581 #[serde(rename = "Image")]
4582 #[serde(skip_serializing_if = "Option::is_none")]
4583 pub image: Option<String>,
4585 #[serde(rename = "ImageID")]
4586 #[serde(skip_serializing_if = "Option::is_none")]
4587 pub image_id: Option<String>,
4589 #[serde(rename = "IsInfra")]
4590 #[serde(skip_serializing_if = "Option::is_none")]
4591 pub is_infra: Option<bool>,
4593 #[serde(rename = "Labels")]
4594 #[serde(skip_serializing_if = "Option::is_none")]
4595 pub labels: Option<HashMap<String, String>>,
4597 #[serde(rename = "Mounts")]
4598 #[serde(skip_serializing_if = "Option::is_none")]
4599 pub mounts: Option<Vec<String>>,
4601 #[serde(rename = "Names")]
4602 #[serde(skip_serializing_if = "Option::is_none")]
4603 pub names: Option<Vec<String>>,
4605 #[serde(rename = "Namespaces")]
4606 pub namespaces: Option<ListContainerNamespaces>,
4607 #[serde(rename = "Networks")]
4608 #[serde(skip_serializing_if = "Option::is_none")]
4609 pub networks: Option<Vec<String>>,
4611 #[serde(rename = "Pid")]
4612 #[serde(skip_serializing_if = "Option::is_none")]
4613 pub pid: Option<i64>,
4615 #[serde(rename = "Pod")]
4616 #[serde(skip_serializing_if = "Option::is_none")]
4617 pub pod: Option<String>,
4620 #[serde(rename = "PodName")]
4621 #[serde(skip_serializing_if = "Option::is_none")]
4622 pub pod_name: Option<String>,
4625 #[serde(rename = "Ports")]
4626 #[serde(skip_serializing_if = "Option::is_none")]
4627 pub ports: Option<Vec<PortMapping>>,
4629 #[serde(rename = "Size")]
4630 pub size: Option<ContainerSize>,
4631 #[serde(rename = "StartedAt")]
4632 #[serde(skip_serializing_if = "Option::is_none")]
4633 pub started_at: Option<i64>,
4635 #[serde(rename = "State")]
4636 #[serde(skip_serializing_if = "Option::is_none")]
4637 pub state: Option<String>,
4639 #[serde(rename = "Status")]
4640 #[serde(skip_serializing_if = "Option::is_none")]
4641 pub status: Option<String>,
4643}
4644
4645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4646pub struct ListContainerNamespaces {
4648 #[serde(rename = "Cgroup")]
4649 #[serde(skip_serializing_if = "Option::is_none")]
4650 pub cgroup: Option<String>,
4652 #[serde(rename = "Ipc")]
4653 #[serde(skip_serializing_if = "Option::is_none")]
4654 pub ipc: Option<String>,
4656 #[serde(rename = "Mnt")]
4657 #[serde(skip_serializing_if = "Option::is_none")]
4658 pub mnt: Option<String>,
4660 #[serde(rename = "Net")]
4661 #[serde(skip_serializing_if = "Option::is_none")]
4662 pub net: Option<String>,
4664 #[serde(rename = "Pidns")]
4665 #[serde(skip_serializing_if = "Option::is_none")]
4666 pub pidns: Option<String>,
4668 #[serde(rename = "User")]
4669 #[serde(skip_serializing_if = "Option::is_none")]
4670 pub user: Option<String>,
4672 #[serde(rename = "Uts")]
4673 #[serde(skip_serializing_if = "Option::is_none")]
4674 pub uts: Option<String>,
4676}
4677
4678#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4679pub struct ListPodContainer {
4680 #[serde(rename = "Id")]
4681 #[serde(skip_serializing_if = "Option::is_none")]
4682 pub id: Option<String>,
4683 #[serde(rename = "Names")]
4684 #[serde(skip_serializing_if = "Option::is_none")]
4685 pub names: Option<String>,
4686 #[serde(rename = "Status")]
4687 #[serde(skip_serializing_if = "Option::is_none")]
4688 pub status: Option<String>,
4689}
4690
4691#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4692pub struct ListPodsReport {
4693 #[serde(rename = "Cgroup")]
4694 #[serde(skip_serializing_if = "Option::is_none")]
4695 pub cgroup: Option<String>,
4696 #[serde(rename = "Containers")]
4697 #[serde(skip_serializing_if = "Option::is_none")]
4698 pub containers: Option<Vec<ListPodContainer>>,
4699 #[serde(rename = "Created")]
4700 #[serde(skip_serializing_if = "Option::is_none")]
4701 pub created: Option<DateTime<Utc>>,
4702 #[serde(rename = "Id")]
4703 #[serde(skip_serializing_if = "Option::is_none")]
4704 pub id: Option<String>,
4705 #[serde(rename = "InfraId")]
4706 #[serde(skip_serializing_if = "Option::is_none")]
4707 pub infra_id: Option<String>,
4708 #[serde(rename = "Labels")]
4709 #[serde(skip_serializing_if = "Option::is_none")]
4710 pub labels: Option<HashMap<String, String>>,
4711 #[serde(rename = "Name")]
4712 #[serde(skip_serializing_if = "Option::is_none")]
4713 pub name: Option<String>,
4714 #[serde(rename = "Namespace")]
4715 #[serde(skip_serializing_if = "Option::is_none")]
4716 pub namespace: Option<String>,
4717 #[serde(rename = "Networks")]
4718 #[serde(skip_serializing_if = "Option::is_none")]
4719 pub networks: Option<Vec<String>>,
4721 #[serde(rename = "Status")]
4722 #[serde(skip_serializing_if = "Option::is_none")]
4723 pub status: Option<String>,
4724}
4725
4726#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4727pub struct ListResponse {
4729 #[serde(rename = "Volumes")]
4730 #[serde(skip_serializing_if = "Option::is_none")]
4731 pub volumes: Option<Vec<Volume>>,
4733 #[serde(rename = "Warnings")]
4734 #[serde(skip_serializing_if = "Option::is_none")]
4735 pub warnings: Option<Vec<String>>,
4737}
4738
4739#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4740pub struct LogConfig {
4741 #[serde(rename = "Config")]
4742 #[serde(skip_serializing_if = "Option::is_none")]
4743 pub config: Option<HashMap<String, String>>,
4744 #[serde(rename = "Type")]
4745 #[serde(skip_serializing_if = "Option::is_none")]
4746 pub type_: Option<String>,
4747}
4748
4749#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4750pub struct LogConfigLibpod {
4752 #[serde(skip_serializing_if = "Option::is_none")]
4753 pub driver: Option<String>,
4756 #[serde(skip_serializing_if = "Option::is_none")]
4757 pub options: Option<HashMap<String, String>>,
4760 #[serde(skip_serializing_if = "Option::is_none")]
4761 pub path: Option<String>,
4765 #[serde(skip_serializing_if = "Option::is_none")]
4766 pub size: Option<i64>,
4769}
4770
4771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4772pub struct ManifestAddOptions {
4774 #[serde(skip_serializing_if = "Option::is_none")]
4775 pub all: Option<bool>,
4777 #[serde(skip_serializing_if = "Option::is_none")]
4778 pub annotation: Option<Vec<String>>,
4780 #[serde(skip_serializing_if = "Option::is_none")]
4781 pub annotations: Option<HashMap<String, String>>,
4783 #[serde(skip_serializing_if = "Option::is_none")]
4784 pub arch: Option<String>,
4786 #[serde(skip_serializing_if = "Option::is_none")]
4787 pub features: Option<Vec<String>>,
4789 #[serde(skip_serializing_if = "Option::is_none")]
4790 pub images: Option<Vec<String>>,
4792 #[serde(skip_serializing_if = "Option::is_none")]
4793 pub os: Option<String>,
4795 #[serde(skip_serializing_if = "Option::is_none")]
4796 pub os_features: Option<Vec<String>>,
4798 #[serde(skip_serializing_if = "Option::is_none")]
4799 pub os_version: Option<String>,
4801 #[serde(skip_serializing_if = "Option::is_none")]
4802 pub variant: Option<String>,
4804}
4805
4806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4807pub struct ManifestAnnotateOptions {
4809 #[serde(skip_serializing_if = "Option::is_none")]
4810 pub annotation: Option<Vec<String>>,
4812 #[serde(skip_serializing_if = "Option::is_none")]
4813 pub annotations: Option<HashMap<String, String>>,
4815 #[serde(skip_serializing_if = "Option::is_none")]
4816 pub arch: Option<String>,
4818 #[serde(skip_serializing_if = "Option::is_none")]
4819 pub features: Option<Vec<String>>,
4821 #[serde(skip_serializing_if = "Option::is_none")]
4822 pub os: Option<String>,
4824 #[serde(skip_serializing_if = "Option::is_none")]
4825 pub os_features: Option<Vec<String>>,
4827 #[serde(skip_serializing_if = "Option::is_none")]
4828 pub os_version: Option<String>,
4830 #[serde(skip_serializing_if = "Option::is_none")]
4831 pub variant: Option<String>,
4833}
4834
4835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4836pub struct ManifestModifyOptions {
4842 #[serde(skip_serializing_if = "Option::is_none")]
4843 pub all: Option<bool>,
4845 #[serde(skip_serializing_if = "Option::is_none")]
4846 pub annotation: Option<Vec<String>>,
4848 #[serde(skip_serializing_if = "Option::is_none")]
4849 pub annotations: Option<HashMap<String, String>>,
4851 #[serde(skip_serializing_if = "Option::is_none")]
4852 pub arch: Option<String>,
4854 #[serde(skip_serializing_if = "Option::is_none")]
4855 pub features: Option<Vec<String>>,
4857 #[serde(skip_serializing_if = "Option::is_none")]
4858 pub images: Option<Vec<String>>,
4860 #[serde(skip_serializing_if = "Option::is_none")]
4861 pub operation: Option<String>,
4862 #[serde(skip_serializing_if = "Option::is_none")]
4863 pub os: Option<String>,
4865 #[serde(skip_serializing_if = "Option::is_none")]
4866 pub os_features: Option<Vec<String>>,
4868 #[serde(skip_serializing_if = "Option::is_none")]
4869 pub os_version: Option<String>,
4871 #[serde(skip_serializing_if = "Option::is_none")]
4872 pub variant: Option<String>,
4874}
4875
4876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4877pub struct ManifestModifyReport {
4879 #[serde(rename = "Id")]
4880 #[serde(skip_serializing_if = "Option::is_none")]
4881 pub id: Option<String>,
4883 #[serde(skip_serializing_if = "Option::is_none")]
4884 pub errors: Option<Vec<String>>,
4886 #[serde(skip_serializing_if = "Option::is_none")]
4887 pub images: Option<Vec<String>>,
4889}
4890
4891#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4892pub struct ManifestPushReport {
4894 #[serde(rename = "Id")]
4895 #[serde(skip_serializing_if = "Option::is_none")]
4896 pub id: Option<String>,
4898 #[serde(skip_serializing_if = "Option::is_none")]
4899 pub error: Option<String>,
4901 #[serde(skip_serializing_if = "Option::is_none")]
4902 pub stream: Option<String>,
4904}
4905
4906pub type ManifestRemoveOptions = Value;
4908
4909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4910pub struct ManifestRemoveReport {
4912 #[serde(rename = "Deleted")]
4913 #[serde(skip_serializing_if = "Option::is_none")]
4914 pub deleted: Option<Vec<String>>,
4916 #[serde(rename = "Errors")]
4917 #[serde(skip_serializing_if = "Option::is_none")]
4918 pub errors: Option<Vec<String>>,
4920 #[serde(rename = "ExitCode")]
4921 #[serde(skip_serializing_if = "Option::is_none")]
4922 pub exit_code: Option<i64>,
4925 #[serde(rename = "Untagged")]
4926 #[serde(skip_serializing_if = "Option::is_none")]
4927 pub untagged: Option<Vec<String>>,
4929}
4930
4931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4932pub struct Meta {
4933 #[serde(rename = "CreatedAt")]
4934 #[serde(skip_serializing_if = "Option::is_none")]
4935 pub created_at: Option<DateTime<Utc>>,
4936 #[serde(rename = "UpdatedAt")]
4937 #[serde(skip_serializing_if = "Option::is_none")]
4938 pub updated_at: Option<DateTime<Utc>>,
4939 #[serde(rename = "Version")]
4940 pub version: Option<Version>,
4941}
4942
4943#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4944pub struct Mount {
4945 #[serde(rename = "BindOptions")]
4946 pub bind_options: Option<BindOptions>,
4947 #[serde(rename = "ClusterOptions")]
4948 pub cluster_options: Option<ClusterOptions>,
4949 #[serde(rename = "Consistency")]
4950 pub consistency: Option<String>,
4951 #[serde(rename = "ReadOnly")]
4952 #[serde(skip_serializing_if = "Option::is_none")]
4953 pub read_only: Option<bool>,
4954 #[serde(rename = "Source")]
4955 #[serde(skip_serializing_if = "Option::is_none")]
4956 pub source: Option<String>,
4960 #[serde(rename = "Target")]
4961 #[serde(skip_serializing_if = "Option::is_none")]
4962 pub target: Option<String>,
4963 #[serde(rename = "TmpfsOptions")]
4964 pub tmpfs_options: Option<TmpfsOptions>,
4965 #[serde(rename = "Type")]
4966 pub type_: Option<String>,
4967 #[serde(rename = "VolumeOptions")]
4968 pub volume_options: Option<VolumeOptions>,
4969}
4970
4971#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4972pub struct MountPoint {
4974 #[serde(rename = "Destination")]
4975 #[serde(skip_serializing_if = "Option::is_none")]
4976 pub destination: Option<String>,
4979 #[serde(rename = "Driver")]
4980 #[serde(skip_serializing_if = "Option::is_none")]
4981 pub driver: Option<String>,
4983 #[serde(rename = "Mode")]
4984 #[serde(skip_serializing_if = "Option::is_none")]
4985 pub mode: Option<String>,
4990 #[serde(rename = "Name")]
4991 #[serde(skip_serializing_if = "Option::is_none")]
4992 pub name: Option<String>,
4995 #[serde(rename = "Propagation")]
4996 pub propagation: Option<String>,
4997 #[serde(rename = "RW")]
4998 #[serde(skip_serializing_if = "Option::is_none")]
4999 pub rw: Option<bool>,
5001 #[serde(rename = "Source")]
5002 #[serde(skip_serializing_if = "Option::is_none")]
5003 pub source: Option<String>,
5010 #[serde(rename = "Type")]
5011 pub type_: Option<String>,
5012}
5013
5014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5015pub struct NamedVolume {
5018 #[serde(rename = "Dest")]
5019 #[serde(skip_serializing_if = "Option::is_none")]
5020 pub dest: Option<String>,
5023 #[serde(rename = "IsAnonymous")]
5024 #[serde(skip_serializing_if = "Option::is_none")]
5025 pub is_anonymous: Option<bool>,
5028 #[serde(rename = "Name")]
5029 #[serde(skip_serializing_if = "Option::is_none")]
5030 pub name: Option<String>,
5034 #[serde(rename = "Options")]
5035 #[serde(skip_serializing_if = "Option::is_none")]
5036 pub options: Option<Vec<String>>,
5038 #[serde(rename = "SubPath")]
5039 #[serde(skip_serializing_if = "Option::is_none")]
5040 pub sub_path: Option<String>,
5042}
5043
5044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5045pub struct Namespace {
5047 pub nsmode: Option<String>,
5048 #[serde(skip_serializing_if = "Option::is_none")]
5049 pub value: Option<String>,
5050}
5051
5052pub type NamespaceMode = String;
5053
5054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5055pub struct NetOptions {
5058 #[serde(skip_serializing_if = "Option::is_none")]
5059 pub dns_option: Option<Vec<String>>,
5060 #[serde(skip_serializing_if = "Option::is_none")]
5061 pub dns_search: Option<Vec<String>>,
5062 #[serde(skip_serializing_if = "Option::is_none")]
5063 pub dns_server: Option<Vec<String>>,
5064 #[serde(skip_serializing_if = "Option::is_none")]
5065 pub hostadd: Option<Vec<String>>,
5066 pub netns: Option<Namespace>,
5067 #[serde(skip_serializing_if = "Option::is_none")]
5068 pub network_alias: Option<Vec<String>>,
5069 #[serde(skip_serializing_if = "Option::is_none")]
5070 pub network_options: Option<HashMap<String, Vec<String>>>,
5072 #[serde(skip_serializing_if = "Option::is_none")]
5073 pub networks: Option<HashMap<String, PerNetworkOptions>>,
5074 #[serde(skip_serializing_if = "Option::is_none")]
5075 pub no_manage_hosts: Option<bool>,
5076 #[serde(skip_serializing_if = "Option::is_none")]
5077 pub no_manage_resolv_conf: Option<bool>,
5078 #[serde(skip_serializing_if = "Option::is_none")]
5079 pub portmappings: Option<Vec<PortMapping>>,
5080}
5081
5082#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5083pub struct Network {
5084 #[serde(skip_serializing_if = "Option::is_none")]
5085 pub created: Option<DateTime<Utc>>,
5087 #[serde(skip_serializing_if = "Option::is_none")]
5088 pub dns_enabled: Option<bool>,
5091 #[serde(skip_serializing_if = "Option::is_none")]
5092 pub driver: Option<String>,
5094 #[serde(skip_serializing_if = "Option::is_none")]
5095 pub id: Option<String>,
5097 #[serde(skip_serializing_if = "Option::is_none")]
5098 pub internal: Option<bool>,
5101 #[serde(skip_serializing_if = "Option::is_none")]
5102 pub ipam_options: Option<HashMap<String, String>>,
5104 #[serde(rename = "ipv6_enabled")]
5105 #[serde(skip_serializing_if = "Option::is_none")]
5106 pub ipv_6_enabled: Option<bool>,
5108 #[serde(skip_serializing_if = "Option::is_none")]
5109 pub labels: Option<HashMap<String, String>>,
5112 #[serde(skip_serializing_if = "Option::is_none")]
5113 pub name: Option<String>,
5115 #[serde(skip_serializing_if = "Option::is_none")]
5116 pub network_dns_servers: Option<Vec<String>>,
5120 #[serde(skip_serializing_if = "Option::is_none")]
5121 pub network_interface: Option<String>,
5123 #[serde(skip_serializing_if = "Option::is_none")]
5124 pub options: Option<HashMap<String, String>>,
5127 #[serde(skip_serializing_if = "Option::is_none")]
5128 pub subnets: Option<Vec<Subnet>>,
5130}
5131
5132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5133pub struct NetworkConnect {
5135 #[serde(rename = "Container")]
5136 #[serde(skip_serializing_if = "Option::is_none")]
5137 pub container: Option<String>,
5138 #[serde(rename = "EndpointConfig")]
5139 pub endpoint_config: Option<EndpointSettings>,
5140}
5141
5142#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5143pub struct NetworkConnectOptions {
5146 #[serde(skip_serializing_if = "Option::is_none")]
5147 pub aliases: Option<Vec<String>>,
5153 #[serde(skip_serializing_if = "Option::is_none")]
5154 pub container: Option<String>,
5155 #[serde(skip_serializing_if = "Option::is_none")]
5156 pub interface_name: Option<String>,
5159 #[serde(skip_serializing_if = "Option::is_none")]
5160 pub static_ips: Option<Vec<String>>,
5162 #[serde(skip_serializing_if = "Option::is_none")]
5163 pub static_mac: Option<String>,
5165}
5166
5167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5168pub struct NetworkCreate {
5170 #[serde(rename = "Attachable")]
5171 #[serde(skip_serializing_if = "Option::is_none")]
5172 pub attachable: Option<bool>,
5173 #[serde(rename = "CheckDuplicate")]
5174 #[serde(skip_serializing_if = "Option::is_none")]
5175 pub check_duplicate: Option<bool>,
5183 #[serde(rename = "ConfigFrom")]
5184 pub config_from: Option<ConfigReference>,
5185 #[serde(rename = "ConfigOnly")]
5186 #[serde(skip_serializing_if = "Option::is_none")]
5187 pub config_only: Option<bool>,
5188 #[serde(rename = "Driver")]
5189 #[serde(skip_serializing_if = "Option::is_none")]
5190 pub driver: Option<String>,
5191 #[serde(rename = "EnableIPv6")]
5192 #[serde(skip_serializing_if = "Option::is_none")]
5193 pub enable_i_pv_6: Option<bool>,
5194 #[serde(rename = "IPAM")]
5195 pub ipam: Option<Ipam>,
5196 #[serde(rename = "Ingress")]
5197 #[serde(skip_serializing_if = "Option::is_none")]
5198 pub ingress: Option<bool>,
5199 #[serde(rename = "Internal")]
5200 #[serde(skip_serializing_if = "Option::is_none")]
5201 pub internal: Option<bool>,
5202 #[serde(rename = "Labels")]
5203 #[serde(skip_serializing_if = "Option::is_none")]
5204 pub labels: Option<HashMap<String, String>>,
5205 #[serde(rename = "Options")]
5206 #[serde(skip_serializing_if = "Option::is_none")]
5207 pub options: Option<HashMap<String, String>>,
5208 #[serde(rename = "Scope")]
5209 #[serde(skip_serializing_if = "Option::is_none")]
5210 pub scope: Option<String>,
5211}
5212
5213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5214pub struct NetworkCreate201Response {
5216 #[serde(rename = "Id")]
5217 #[serde(skip_serializing_if = "Option::is_none")]
5218 pub id: Option<String>,
5219 #[serde(rename = "Warning")]
5220 #[serde(skip_serializing_if = "Option::is_none")]
5221 pub warning: Option<String>,
5222}
5223
5224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5225pub struct NetworkCreateRequest {
5226 #[serde(rename = "Attachable")]
5227 #[serde(skip_serializing_if = "Option::is_none")]
5228 pub attachable: Option<bool>,
5229 #[serde(rename = "CheckDuplicate")]
5230 #[serde(skip_serializing_if = "Option::is_none")]
5231 pub check_duplicate: Option<bool>,
5239 #[serde(rename = "ConfigFrom")]
5240 pub config_from: Option<ConfigReference>,
5241 #[serde(rename = "ConfigOnly")]
5242 #[serde(skip_serializing_if = "Option::is_none")]
5243 pub config_only: Option<bool>,
5244 #[serde(rename = "Driver")]
5245 #[serde(skip_serializing_if = "Option::is_none")]
5246 pub driver: Option<String>,
5247 #[serde(rename = "EnableIPv6")]
5248 #[serde(skip_serializing_if = "Option::is_none")]
5249 pub enable_i_pv_6: Option<bool>,
5250 #[serde(rename = "IPAM")]
5251 pub ipam: Option<Ipam>,
5252 #[serde(rename = "Ingress")]
5253 #[serde(skip_serializing_if = "Option::is_none")]
5254 pub ingress: Option<bool>,
5255 #[serde(rename = "Internal")]
5256 #[serde(skip_serializing_if = "Option::is_none")]
5257 pub internal: Option<bool>,
5258 #[serde(rename = "Labels")]
5259 #[serde(skip_serializing_if = "Option::is_none")]
5260 pub labels: Option<HashMap<String, String>>,
5261 #[serde(rename = "Name")]
5262 #[serde(skip_serializing_if = "Option::is_none")]
5263 pub name: Option<String>,
5264 #[serde(rename = "Options")]
5265 #[serde(skip_serializing_if = "Option::is_none")]
5266 pub options: Option<HashMap<String, String>>,
5267 #[serde(rename = "Scope")]
5268 #[serde(skip_serializing_if = "Option::is_none")]
5269 pub scope: Option<String>,
5270}
5271
5272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5273pub struct NetworkDisconnect {
5275 #[serde(rename = "Container")]
5276 #[serde(skip_serializing_if = "Option::is_none")]
5277 pub container: Option<String>,
5278 #[serde(rename = "Force")]
5279 #[serde(skip_serializing_if = "Option::is_none")]
5280 pub force: Option<bool>,
5281}
5282
5283pub type NetworkMode = String;
5284
5285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5286pub struct NetworkPrune200Response {
5288 #[serde(rename = "NetworksDeleted")]
5289 #[serde(skip_serializing_if = "Option::is_none")]
5290 pub networks_deleted: Option<Vec<String>>,
5291}
5292
5293#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5294pub struct NetworkPruneReport {
5297 #[serde(rename = "Error")]
5298 #[serde(skip_serializing_if = "Option::is_none")]
5299 pub error: Option<String>,
5300 #[serde(rename = "Name")]
5301 #[serde(skip_serializing_if = "Option::is_none")]
5302 pub name: Option<String>,
5303}
5304
5305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5306pub struct NetworkResource {
5308 #[serde(rename = "Attachable")]
5309 #[serde(skip_serializing_if = "Option::is_none")]
5310 pub attachable: Option<bool>,
5311 #[serde(rename = "ConfigFrom")]
5312 pub config_from: Option<ConfigReference>,
5313 #[serde(rename = "ConfigOnly")]
5314 #[serde(skip_serializing_if = "Option::is_none")]
5315 pub config_only: Option<bool>,
5316 #[serde(rename = "Containers")]
5317 #[serde(skip_serializing_if = "Option::is_none")]
5318 pub containers: Option<HashMap<String, EndpointResource>>,
5319 #[serde(rename = "Created")]
5320 #[serde(skip_serializing_if = "Option::is_none")]
5321 pub created: Option<DateTime<Utc>>,
5322 #[serde(rename = "Driver")]
5323 #[serde(skip_serializing_if = "Option::is_none")]
5324 pub driver: Option<String>,
5325 #[serde(rename = "EnableIPv6")]
5326 #[serde(skip_serializing_if = "Option::is_none")]
5327 pub enable_i_pv_6: Option<bool>,
5328 #[serde(rename = "IPAM")]
5329 pub ipam: Option<Ipam>,
5330 #[serde(rename = "Id")]
5331 #[serde(skip_serializing_if = "Option::is_none")]
5332 pub id: Option<String>,
5333 #[serde(rename = "Ingress")]
5334 #[serde(skip_serializing_if = "Option::is_none")]
5335 pub ingress: Option<bool>,
5336 #[serde(rename = "Internal")]
5337 #[serde(skip_serializing_if = "Option::is_none")]
5338 pub internal: Option<bool>,
5339 #[serde(rename = "Labels")]
5340 #[serde(skip_serializing_if = "Option::is_none")]
5341 pub labels: Option<HashMap<String, String>>,
5342 #[serde(rename = "Name")]
5343 #[serde(skip_serializing_if = "Option::is_none")]
5344 pub name: Option<String>,
5345 #[serde(rename = "Options")]
5346 #[serde(skip_serializing_if = "Option::is_none")]
5347 pub options: Option<HashMap<String, String>>,
5348 #[serde(rename = "Peers")]
5349 #[serde(skip_serializing_if = "Option::is_none")]
5350 pub peers: Option<Vec<PeerInfo>>,
5351 #[serde(rename = "Scope")]
5352 #[serde(skip_serializing_if = "Option::is_none")]
5353 pub scope: Option<String>,
5354 #[serde(rename = "Services")]
5355 #[serde(skip_serializing_if = "Option::is_none")]
5356 pub services: Option<HashMap<String, ServiceInfo>>,
5357}
5358
5359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5360pub struct NetworkRmReport {
5362 #[serde(rename = "Err")]
5363 #[serde(skip_serializing_if = "Option::is_none")]
5364 pub err: Option<String>,
5365 #[serde(rename = "Name")]
5366 #[serde(skip_serializing_if = "Option::is_none")]
5367 pub name: Option<String>,
5368}
5369
5370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5371pub struct NetworkSettings {
5373 #[serde(rename = "Bridge")]
5374 #[serde(skip_serializing_if = "Option::is_none")]
5375 pub bridge: Option<String>,
5376 #[serde(rename = "EndpointID")]
5377 #[serde(skip_serializing_if = "Option::is_none")]
5378 pub endpoint_id: Option<String>,
5379 #[serde(rename = "Gateway")]
5380 #[serde(skip_serializing_if = "Option::is_none")]
5381 pub gateway: Option<String>,
5382 #[serde(rename = "GlobalIPv6Address")]
5383 #[serde(skip_serializing_if = "Option::is_none")]
5384 pub global_i_pv_6_address: Option<String>,
5385 #[serde(rename = "GlobalIPv6PrefixLen")]
5386 #[serde(skip_serializing_if = "Option::is_none")]
5387 pub global_i_pv_6_prefix_len: Option<i64>,
5388 #[serde(rename = "HairpinMode")]
5389 #[serde(skip_serializing_if = "Option::is_none")]
5390 pub hairpin_mode: Option<bool>,
5391 #[serde(rename = "IPAddress")]
5392 #[serde(skip_serializing_if = "Option::is_none")]
5393 pub ip_address: Option<String>,
5394 #[serde(rename = "IPPrefixLen")]
5395 #[serde(skip_serializing_if = "Option::is_none")]
5396 pub ip_prefix_len: Option<i64>,
5397 #[serde(rename = "IPv6Gateway")]
5398 #[serde(skip_serializing_if = "Option::is_none")]
5399 pub i_pv_6_gateway: Option<String>,
5400 #[serde(rename = "LinkLocalIPv6Address")]
5401 #[serde(skip_serializing_if = "Option::is_none")]
5402 pub link_local_i_pv_6_address: Option<String>,
5403 #[serde(rename = "LinkLocalIPv6PrefixLen")]
5404 #[serde(skip_serializing_if = "Option::is_none")]
5405 pub link_local_i_pv_6_prefix_len: Option<i64>,
5406 #[serde(rename = "MacAddress")]
5407 #[serde(skip_serializing_if = "Option::is_none")]
5408 pub mac_address: Option<String>,
5409 #[serde(rename = "Networks")]
5410 #[serde(skip_serializing_if = "Option::is_none")]
5411 pub networks: Option<HashMap<String, EndpointSettings>>,
5412 #[serde(rename = "Ports")]
5413 pub ports: Option<PortMap>,
5414 #[serde(rename = "SandboxID")]
5415 #[serde(skip_serializing_if = "Option::is_none")]
5416 pub sandbox_id: Option<String>,
5417 #[serde(rename = "SandboxKey")]
5418 #[serde(skip_serializing_if = "Option::is_none")]
5419 pub sandbox_key: Option<String>,
5420 #[serde(rename = "SecondaryIPAddresses")]
5421 #[serde(skip_serializing_if = "Option::is_none")]
5422 pub secondary_ip_addresses: Option<Vec<Address>>,
5423 #[serde(rename = "SecondaryIPv6Addresses")]
5424 #[serde(skip_serializing_if = "Option::is_none")]
5425 pub secondary_i_pv_6_addresses: Option<Vec<Address>>,
5426}
5427
5428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5429pub struct NetworkUpdateOptions {
5431 #[serde(skip_serializing_if = "Option::is_none")]
5432 pub adddnsservers: Option<Vec<String>>,
5433 #[serde(skip_serializing_if = "Option::is_none")]
5434 pub removednsservers: Option<Vec<String>>,
5435}
5436
5437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5438pub struct NetworkingConfig {
5441 #[serde(rename = "EndpointsConfig")]
5442 #[serde(skip_serializing_if = "Option::is_none")]
5443 pub endpoints_config: Option<HashMap<String, EndpointSettings>>,
5444}
5445
5446#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5447pub struct NoSuchSecret {
5449 #[serde(skip_serializing_if = "Option::is_none")]
5450 pub cause: Option<String>,
5452 #[serde(skip_serializing_if = "Option::is_none")]
5453 pub message: Option<String>,
5455 #[serde(skip_serializing_if = "Option::is_none")]
5456 pub response: Option<i64>,
5458}
5459
5460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5461pub struct OverlayVolume {
5464 #[serde(skip_serializing_if = "Option::is_none")]
5465 pub destination: Option<String>,
5467 #[serde(skip_serializing_if = "Option::is_none")]
5468 pub options: Option<Vec<String>>,
5470 #[serde(skip_serializing_if = "Option::is_none")]
5471 pub source: Option<String>,
5473}
5474
5475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5476pub struct PosixRlimit {
5478 #[serde(skip_serializing_if = "Option::is_none")]
5479 pub hard: Option<u64>,
5481 #[serde(skip_serializing_if = "Option::is_none")]
5482 pub soft: Option<u64>,
5484 #[serde(rename = "type")]
5485 #[serde(skip_serializing_if = "Option::is_none")]
5486 pub type_: Option<String>,
5488}
5489
5490#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5491pub struct PeerInfo {
5493 #[serde(rename = "IP")]
5494 #[serde(skip_serializing_if = "Option::is_none")]
5495 pub ip: Option<String>,
5496 #[serde(rename = "Name")]
5497 #[serde(skip_serializing_if = "Option::is_none")]
5498 pub name: Option<String>,
5499}
5500
5501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5502pub struct PerNetworkOptions {
5503 #[serde(skip_serializing_if = "Option::is_none")]
5504 pub aliases: Option<Vec<String>>,
5510 #[serde(skip_serializing_if = "Option::is_none")]
5511 pub interface_name: Option<String>,
5514 #[serde(skip_serializing_if = "Option::is_none")]
5515 pub static_ips: Option<Vec<String>>,
5517 #[serde(skip_serializing_if = "Option::is_none")]
5518 pub static_mac: Option<String>,
5520}
5521
5522pub type PidMode = String;
5523
5524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5525pub struct Platform {
5526 #[serde(skip_serializing_if = "Option::is_none")]
5527 pub architecture: Option<String>,
5530 #[serde(skip_serializing_if = "Option::is_none")]
5531 pub os: Option<String>,
5533 #[serde(rename = "os.features")]
5534 #[serde(skip_serializing_if = "Option::is_none")]
5535 pub os_features: Option<Vec<String>>,
5538 #[serde(rename = "os.version")]
5539 #[serde(skip_serializing_if = "Option::is_none")]
5540 pub os_version: Option<String>,
5543 #[serde(skip_serializing_if = "Option::is_none")]
5544 pub variant: Option<String>,
5547}
5548
5549pub type PlayKubeLibpodRequestParam = String;
5550
5551#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5552pub struct PlayKubePod {
5554 #[serde(rename = "ContainerErrors")]
5555 #[serde(skip_serializing_if = "Option::is_none")]
5556 pub container_errors: Option<Vec<String>>,
5559 #[serde(rename = "Containers")]
5560 #[serde(skip_serializing_if = "Option::is_none")]
5561 pub containers: Option<Vec<String>>,
5563 #[serde(rename = "ID")]
5564 #[serde(skip_serializing_if = "Option::is_none")]
5565 pub id: Option<String>,
5567 #[serde(rename = "InitContainers")]
5568 #[serde(skip_serializing_if = "Option::is_none")]
5569 pub init_containers: Option<Vec<String>>,
5571 #[serde(rename = "Logs")]
5572 #[serde(skip_serializing_if = "Option::is_none")]
5573 pub logs: Option<Vec<String>>,
5575}
5576
5577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5578pub struct PlayKubeReport {
5579 #[serde(rename = "Pods")]
5580 #[serde(skip_serializing_if = "Option::is_none")]
5581 pub pods: Option<Vec<PlayKubePod>>,
5583 #[serde(rename = "RmReport")]
5584 #[serde(skip_serializing_if = "Option::is_none")]
5585 pub rm_report: Option<Vec<PodRmReport>>,
5586 #[serde(rename = "SecretRmReport")]
5587 #[serde(skip_serializing_if = "Option::is_none")]
5588 pub secret_rm_report: Option<Vec<SecretRmReport>>,
5589 #[serde(rename = "Secrets")]
5590 #[serde(skip_serializing_if = "Option::is_none")]
5591 pub secrets: Option<Vec<PlaySecret>>,
5593 #[serde(rename = "ServiceContainerID")]
5594 #[serde(skip_serializing_if = "Option::is_none")]
5595 pub service_container_id: Option<String>,
5597 #[serde(rename = "StopReport")]
5598 #[serde(skip_serializing_if = "Option::is_none")]
5599 pub stop_report: Option<Vec<PodStopReport>>,
5600 #[serde(rename = "VolumeRmReport")]
5601 #[serde(skip_serializing_if = "Option::is_none")]
5602 pub volume_rm_report: Option<Vec<VolumeRmReport>>,
5603 #[serde(rename = "Volumes")]
5604 #[serde(skip_serializing_if = "Option::is_none")]
5605 pub volumes: Option<Vec<PlayKubeVolume>>,
5607}
5608
5609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5610pub struct PlayKubeVolume {
5611 #[serde(rename = "Name")]
5612 #[serde(skip_serializing_if = "Option::is_none")]
5613 pub name: Option<String>,
5615}
5616
5617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5618pub struct PlaySecret {
5619 #[serde(rename = "CreateReport")]
5620 pub create_report: Option<SecretCreateReport>,
5621}
5622
5623#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5624pub struct Plugin {
5626 #[serde(rename = "Config")]
5627 pub config: PluginConfig,
5628 #[serde(rename = "Enabled")]
5629 pub enabled: bool,
5631 #[serde(rename = "Id")]
5632 #[serde(skip_serializing_if = "Option::is_none")]
5633 pub id: Option<String>,
5635 #[serde(rename = "Name")]
5636 pub name: String,
5638 #[serde(rename = "PluginReference")]
5639 #[serde(skip_serializing_if = "Option::is_none")]
5640 pub plugin_reference: Option<String>,
5642 #[serde(rename = "Settings")]
5643 pub settings: PluginSettings,
5644}
5645
5646#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5647pub struct PluginConfig {
5648 #[serde(rename = "Args")]
5649 pub args: PluginConfigArgs,
5650 #[serde(rename = "Description")]
5651 pub description: String,
5653 #[serde(rename = "DockerVersion")]
5654 #[serde(skip_serializing_if = "Option::is_none")]
5655 pub docker_version: Option<String>,
5657 #[serde(rename = "Documentation")]
5658 pub documentation: String,
5660 #[serde(rename = "Entrypoint")]
5661 #[serde(default)]
5662 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5663 pub entrypoint: Vec<String>,
5665 #[serde(rename = "Env")]
5666 #[serde(default)]
5667 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5668 pub env: Vec<PluginEnv>,
5670 #[serde(rename = "Interface")]
5671 pub interface: PluginConfigInterface,
5672 #[serde(rename = "IpcHost")]
5673 pub ipc_host: bool,
5675 #[serde(rename = "Linux")]
5676 pub linux: PluginConfigLinux,
5677 #[serde(rename = "Mounts")]
5678 #[serde(default)]
5679 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5680 pub mounts: Vec<PluginMount>,
5682 #[serde(rename = "Network")]
5683 pub network: PluginConfigNetwork,
5684 #[serde(rename = "PidHost")]
5685 pub pid_host: bool,
5687 #[serde(rename = "PropagatedMount")]
5688 pub propagated_mount: String,
5690 #[serde(rename = "User")]
5691 pub user: Option<PluginConfigUser>,
5692 #[serde(rename = "WorkDir")]
5693 pub work_dir: String,
5695 pub rootfs: Option<PluginConfigRootfs>,
5696}
5697
5698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5699pub struct PluginConfigArgs {
5701 #[serde(rename = "Description")]
5702 pub description: String,
5704 #[serde(rename = "Name")]
5705 pub name: String,
5707 #[serde(rename = "Settable")]
5708 #[serde(default)]
5709 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5710 pub settable: Vec<String>,
5712 #[serde(rename = "Value")]
5713 #[serde(default)]
5714 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5715 pub value: Vec<String>,
5717}
5718
5719#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5720pub struct PluginConfigInterface {
5722 #[serde(rename = "ProtocolScheme")]
5723 #[serde(skip_serializing_if = "Option::is_none")]
5724 pub protocol_scheme: Option<String>,
5726 #[serde(rename = "Socket")]
5727 pub socket: String,
5729 #[serde(rename = "Types")]
5730 #[serde(default)]
5731 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5732 pub types: Vec<PluginInterfaceType>,
5734}
5735
5736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5737pub struct PluginConfigLinux {
5739 #[serde(rename = "AllowAllDevices")]
5740 pub allow_all_devices: bool,
5742 #[serde(rename = "Capabilities")]
5743 #[serde(default)]
5744 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5745 pub capabilities: Vec<String>,
5747 #[serde(rename = "Devices")]
5748 #[serde(default)]
5749 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5750 pub devices: Vec<PluginDevice>,
5752}
5753
5754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5755pub struct PluginConfigNetwork {
5757 #[serde(rename = "Type")]
5758 pub type_: String,
5760}
5761
5762#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5763pub struct PluginConfigRootfs {
5765 #[serde(skip_serializing_if = "Option::is_none")]
5766 pub diff_ids: Option<Vec<String>>,
5768 #[serde(rename = "type")]
5769 #[serde(skip_serializing_if = "Option::is_none")]
5770 pub type_: Option<String>,
5772}
5773
5774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5775pub struct PluginConfigUser {
5777 #[serde(rename = "GID")]
5778 #[serde(skip_serializing_if = "Option::is_none")]
5779 pub gid: Option<u32>,
5781 #[serde(rename = "UID")]
5782 #[serde(skip_serializing_if = "Option::is_none")]
5783 pub uid: Option<u32>,
5785}
5786
5787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5788pub struct PluginDevice {
5790 #[serde(rename = "Description")]
5791 pub description: String,
5793 #[serde(rename = "Name")]
5794 pub name: String,
5796 #[serde(rename = "Path")]
5797 pub path: String,
5799 #[serde(rename = "Settable")]
5800 #[serde(default)]
5801 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5802 pub settable: Vec<String>,
5804}
5805
5806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5807pub struct PluginEnv {
5809 #[serde(rename = "Description")]
5810 pub description: String,
5812 #[serde(rename = "Name")]
5813 pub name: String,
5815 #[serde(rename = "Settable")]
5816 #[serde(default)]
5817 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5818 pub settable: Vec<String>,
5820 #[serde(rename = "Value")]
5821 pub value: String,
5823}
5824
5825#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5826pub struct PluginInterfaceType {
5828 #[serde(rename = "Capability")]
5829 pub capability: String,
5831 #[serde(rename = "Prefix")]
5832 pub prefix: String,
5834 #[serde(rename = "Version")]
5835 pub version: String,
5837}
5838
5839#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5840pub struct PluginMount {
5842 #[serde(rename = "Description")]
5843 pub description: String,
5845 #[serde(rename = "Destination")]
5846 pub destination: String,
5848 #[serde(rename = "Name")]
5849 pub name: String,
5851 #[serde(rename = "Options")]
5852 #[serde(default)]
5853 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5854 pub options: Vec<String>,
5856 #[serde(rename = "Settable")]
5857 #[serde(default)]
5858 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5859 pub settable: Vec<String>,
5861 #[serde(rename = "Source")]
5862 pub source: String,
5864 #[serde(rename = "Type")]
5865 pub type_: String,
5867}
5868
5869#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5870pub struct PluginSettings {
5871 #[serde(rename = "Args")]
5872 #[serde(default)]
5873 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5874 pub args: Vec<String>,
5876 #[serde(rename = "Devices")]
5877 #[serde(default)]
5878 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5879 pub devices: Vec<PluginDevice>,
5881 #[serde(rename = "Env")]
5882 #[serde(default)]
5883 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5884 pub env: Vec<String>,
5886 #[serde(rename = "Mounts")]
5887 #[serde(default)]
5888 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5889 pub mounts: Vec<PluginMount>,
5891}
5892
5893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5894pub struct PodBasicConfig {
5895 #[serde(skip_serializing_if = "Option::is_none")]
5896 pub exit_policy: Option<String>,
5898 #[serde(skip_serializing_if = "Option::is_none")]
5899 pub hostname: Option<String>,
5905 #[serde(skip_serializing_if = "Option::is_none")]
5906 pub infra_command: Option<Vec<String>>,
5913 #[serde(skip_serializing_if = "Option::is_none")]
5914 pub infra_conmon_pid_file: Option<String>,
5917 #[serde(skip_serializing_if = "Option::is_none")]
5918 pub infra_image: Option<String>,
5924 #[serde(skip_serializing_if = "Option::is_none")]
5925 pub infra_name: Option<String>,
5931 pub ipcns: Option<Namespace>,
5932 #[serde(skip_serializing_if = "Option::is_none")]
5933 pub labels: Option<HashMap<String, String>>,
5936 #[serde(skip_serializing_if = "Option::is_none")]
5937 pub name: Option<String>,
5941 #[serde(skip_serializing_if = "Option::is_none")]
5942 pub no_infra: Option<bool>,
5948 pub pidns: Option<Namespace>,
5949 #[serde(skip_serializing_if = "Option::is_none")]
5950 pub pod_create_command: Option<Vec<String>>,
5951 #[serde(skip_serializing_if = "Option::is_none")]
5952 pub pod_devices: Option<Vec<String>>,
5954 #[serde(skip_serializing_if = "Option::is_none")]
5955 pub share_parent: Option<bool>,
5962 #[serde(skip_serializing_if = "Option::is_none")]
5963 pub shared_namespaces: Option<Vec<String>>,
5971 #[serde(skip_serializing_if = "Option::is_none")]
5972 pub sysctl: Option<HashMap<String, String>>,
5974 pub userns: Option<Namespace>,
5975 pub utsns: Option<Namespace>,
5976}
5977
5978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5979pub struct PodCgroupConfig {
5981 #[serde(skip_serializing_if = "Option::is_none")]
5982 pub cgroup_parent: Option<String>,
5987}
5988
5989pub type PodCreateLibpod409Response = String;
5991
5992#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5993pub struct PodCreateOptions {
5995 #[serde(skip_serializing_if = "Option::is_none")]
5996 pub cgroup_parent: Option<String>,
5997 #[serde(skip_serializing_if = "Option::is_none")]
5998 pub container_command: Option<String>,
5999 #[serde(skip_serializing_if = "Option::is_none")]
6000 pub container_conmon_pidfile: Option<String>,
6001 #[serde(skip_serializing_if = "Option::is_none")]
6002 pub container_name: Option<String>,
6003 #[serde(skip_serializing_if = "Option::is_none")]
6004 pub cpus: Option<f64>,
6005 #[serde(skip_serializing_if = "Option::is_none")]
6006 pub cpuset_cpus: Option<String>,
6007 #[serde(skip_serializing_if = "Option::is_none")]
6008 pub create_command: Option<Vec<String>>,
6009 #[serde(skip_serializing_if = "Option::is_none")]
6010 pub device_read_bps: Option<Vec<String>>,
6011 #[serde(skip_serializing_if = "Option::is_none")]
6012 pub devices: Option<Vec<String>>,
6013 #[serde(skip_serializing_if = "Option::is_none")]
6014 pub exit_policy: Option<String>,
6015 #[serde(skip_serializing_if = "Option::is_none")]
6016 pub hostname: Option<String>,
6017 #[serde(skip_serializing_if = "Option::is_none")]
6018 pub infra: Option<bool>,
6019 #[serde(skip_serializing_if = "Option::is_none")]
6020 pub infra_image: Option<String>,
6021 #[serde(skip_serializing_if = "Option::is_none")]
6022 pub ipc: Option<String>,
6023 #[serde(skip_serializing_if = "Option::is_none")]
6024 pub labels: Option<HashMap<String, String>>,
6025 #[serde(skip_serializing_if = "Option::is_none")]
6026 pub name: Option<String>,
6027 pub net: Option<NetOptions>,
6028 #[serde(skip_serializing_if = "Option::is_none")]
6029 pub pid: Option<String>,
6030 #[serde(skip_serializing_if = "Option::is_none")]
6031 pub security_opt: Option<Vec<String>>,
6032 #[serde(skip_serializing_if = "Option::is_none")]
6033 pub share: Option<Vec<String>>,
6034 #[serde(skip_serializing_if = "Option::is_none")]
6035 pub share_parent: Option<bool>,
6036 #[serde(skip_serializing_if = "Option::is_none")]
6037 pub sysctl: Option<Vec<String>>,
6038 #[serde(skip_serializing_if = "Option::is_none")]
6039 pub volume: Option<Vec<String>>,
6040 #[serde(skip_serializing_if = "Option::is_none")]
6041 pub volumes_from: Option<Vec<String>>,
6042}
6043
6044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6045pub struct PodKillReport {
6046 #[serde(rename = "Errs")]
6047 #[serde(skip_serializing_if = "Option::is_none")]
6048 pub errs: Option<Vec<String>>,
6049 #[serde(rename = "Id")]
6050 #[serde(skip_serializing_if = "Option::is_none")]
6051 pub id: Option<String>,
6052}
6053
6054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6055pub struct PodNetworkConfig {
6056 #[serde(rename = "Networks")]
6057 #[serde(skip_serializing_if = "Option::is_none")]
6058 pub networks: Option<HashMap<String, PerNetworkOptions>>,
6065 #[serde(skip_serializing_if = "Option::is_none")]
6066 pub cni_networks: Option<Vec<String>>,
6074 #[serde(skip_serializing_if = "Option::is_none")]
6075 pub dns_option: Option<Vec<String>>,
6081 #[serde(skip_serializing_if = "Option::is_none")]
6082 pub dns_search: Option<Vec<String>>,
6090 #[serde(skip_serializing_if = "Option::is_none")]
6091 pub dns_server: Option<Vec<String>>,
6100 #[serde(skip_serializing_if = "Option::is_none")]
6101 pub hostadd: Option<Vec<String>>,
6107 pub netns: Option<Namespace>,
6108 #[serde(skip_serializing_if = "Option::is_none")]
6109 pub network_options: Option<HashMap<String, Vec<String>>>,
6112 #[serde(skip_serializing_if = "Option::is_none")]
6113 pub no_manage_hosts: Option<bool>,
6118 #[serde(skip_serializing_if = "Option::is_none")]
6119 pub no_manage_resolv_conf: Option<bool>,
6125 #[serde(skip_serializing_if = "Option::is_none")]
6126 pub portmappings: Option<Vec<PortMapping>>,
6132}
6133
6134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6135pub struct PodPauseReport {
6136 #[serde(rename = "Errs")]
6137 #[serde(skip_serializing_if = "Option::is_none")]
6138 pub errs: Option<Vec<String>>,
6139 #[serde(rename = "Id")]
6140 #[serde(skip_serializing_if = "Option::is_none")]
6141 pub id: Option<String>,
6142}
6143
6144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6145pub struct PodPruneReport {
6146 #[serde(rename = "Err")]
6147 #[serde(skip_serializing_if = "Option::is_none")]
6148 pub err: Option<String>,
6149 #[serde(rename = "Id")]
6150 #[serde(skip_serializing_if = "Option::is_none")]
6151 pub id: Option<String>,
6152}
6153
6154#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6155pub struct PodResourceConfig {
6156 #[serde(skip_serializing_if = "Option::is_none")]
6157 pub cpu_period: Option<u64>,
6159 #[serde(skip_serializing_if = "Option::is_none")]
6160 pub cpu_quota: Option<i64>,
6162 pub resource_limits: Option<LinuxResources>,
6163 #[serde(rename = "throttleReadBpsDevice")]
6164 #[serde(skip_serializing_if = "Option::is_none")]
6165 pub throttle_read_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
6167}
6168
6169#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6170pub struct PodRestartReport {
6171 #[serde(rename = "Errs")]
6172 #[serde(skip_serializing_if = "Option::is_none")]
6173 pub errs: Option<Vec<String>>,
6174 #[serde(rename = "Id")]
6175 #[serde(skip_serializing_if = "Option::is_none")]
6176 pub id: Option<String>,
6177}
6178
6179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6180pub struct PodRmReport {
6181 #[serde(rename = "Err")]
6182 #[serde(skip_serializing_if = "Option::is_none")]
6183 pub err: Option<String>,
6184 #[serde(rename = "Id")]
6185 #[serde(skip_serializing_if = "Option::is_none")]
6186 pub id: Option<String>,
6187}
6188
6189#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6190pub struct PodSecurityConfig {
6191 pub idmappings: Option<IdMappingOptions>,
6192 #[serde(skip_serializing_if = "Option::is_none")]
6193 pub security_opt: Option<Vec<String>>,
6194}
6195
6196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6197pub struct PodSpecGenerator {
6199 #[serde(rename = "Networks")]
6200 #[serde(skip_serializing_if = "Option::is_none")]
6201 pub networks: Option<HashMap<String, PerNetworkOptions>>,
6208 #[serde(skip_serializing_if = "Option::is_none")]
6209 pub cgroup_parent: Option<String>,
6214 #[serde(skip_serializing_if = "Option::is_none")]
6215 pub cni_networks: Option<Vec<String>>,
6223 #[serde(skip_serializing_if = "Option::is_none")]
6224 pub cpu_period: Option<u64>,
6226 #[serde(skip_serializing_if = "Option::is_none")]
6227 pub cpu_quota: Option<i64>,
6229 #[serde(skip_serializing_if = "Option::is_none")]
6230 pub dns_option: Option<Vec<String>>,
6236 #[serde(skip_serializing_if = "Option::is_none")]
6237 pub dns_search: Option<Vec<String>>,
6245 #[serde(skip_serializing_if = "Option::is_none")]
6246 pub dns_server: Option<Vec<String>>,
6255 #[serde(skip_serializing_if = "Option::is_none")]
6256 pub exit_policy: Option<String>,
6258 #[serde(skip_serializing_if = "Option::is_none")]
6259 pub hostadd: Option<Vec<String>>,
6265 #[serde(skip_serializing_if = "Option::is_none")]
6266 pub hostname: Option<String>,
6272 pub idmappings: Option<IdMappingOptions>,
6273 #[serde(skip_serializing_if = "Option::is_none")]
6274 pub image_volumes: Option<Vec<ImageVolume>>,
6277 #[serde(skip_serializing_if = "Option::is_none")]
6278 pub infra_command: Option<Vec<String>>,
6285 #[serde(skip_serializing_if = "Option::is_none")]
6286 pub infra_conmon_pid_file: Option<String>,
6289 #[serde(skip_serializing_if = "Option::is_none")]
6290 pub infra_image: Option<String>,
6296 #[serde(skip_serializing_if = "Option::is_none")]
6297 pub infra_name: Option<String>,
6303 pub ipcns: Option<Namespace>,
6304 #[serde(skip_serializing_if = "Option::is_none")]
6305 pub labels: Option<HashMap<String, String>>,
6308 #[serde(skip_serializing_if = "Option::is_none")]
6309 pub mounts: Option<Vec<Mount>>,
6314 #[serde(skip_serializing_if = "Option::is_none")]
6315 pub name: Option<String>,
6319 pub netns: Option<Namespace>,
6320 #[serde(skip_serializing_if = "Option::is_none")]
6321 pub network_options: Option<HashMap<String, Vec<String>>>,
6324 #[serde(skip_serializing_if = "Option::is_none")]
6325 pub no_infra: Option<bool>,
6331 #[serde(skip_serializing_if = "Option::is_none")]
6332 pub no_manage_hosts: Option<bool>,
6337 #[serde(skip_serializing_if = "Option::is_none")]
6338 pub no_manage_resolv_conf: Option<bool>,
6344 #[serde(skip_serializing_if = "Option::is_none")]
6345 pub overlay_volumes: Option<Vec<OverlayVolume>>,
6348 pub pidns: Option<Namespace>,
6349 #[serde(skip_serializing_if = "Option::is_none")]
6350 pub pod_create_command: Option<Vec<String>>,
6351 #[serde(skip_serializing_if = "Option::is_none")]
6352 pub pod_devices: Option<Vec<String>>,
6354 #[serde(skip_serializing_if = "Option::is_none")]
6355 pub portmappings: Option<Vec<PortMapping>>,
6361 pub resource_limits: Option<LinuxResources>,
6362 #[serde(skip_serializing_if = "Option::is_none")]
6363 pub security_opt: Option<Vec<String>>,
6364 #[serde(rename = "serviceContainerID")]
6365 #[serde(skip_serializing_if = "Option::is_none")]
6366 pub service_container_id: Option<String>,
6368 #[serde(skip_serializing_if = "Option::is_none")]
6369 pub share_parent: Option<bool>,
6376 #[serde(skip_serializing_if = "Option::is_none")]
6377 pub shared_namespaces: Option<Vec<String>>,
6385 #[serde(skip_serializing_if = "Option::is_none")]
6386 pub shm_size: Option<i64>,
6390 #[serde(skip_serializing_if = "Option::is_none")]
6391 pub shm_size_systemd: Option<i64>,
6395 #[serde(skip_serializing_if = "Option::is_none")]
6396 pub sysctl: Option<HashMap<String, String>>,
6398 #[serde(rename = "throttleReadBpsDevice")]
6399 #[serde(skip_serializing_if = "Option::is_none")]
6400 pub throttle_read_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
6402 pub userns: Option<Namespace>,
6403 pub utsns: Option<Namespace>,
6404 #[serde(skip_serializing_if = "Option::is_none")]
6405 pub volumes: Option<Vec<NamedVolume>>,
6410 #[serde(skip_serializing_if = "Option::is_none")]
6411 pub volumes_from: Option<Vec<String>>,
6417}
6418
6419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6420pub struct PodStartReport {
6421 #[serde(rename = "Errs")]
6422 #[serde(skip_serializing_if = "Option::is_none")]
6423 pub errs: Option<Vec<String>>,
6424 #[serde(rename = "Id")]
6425 #[serde(skip_serializing_if = "Option::is_none")]
6426 pub id: Option<String>,
6427}
6428
6429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6430pub struct PodStatsReport {
6431 #[serde(rename = "BlockIO")]
6432 #[serde(skip_serializing_if = "Option::is_none")]
6433 pub block_io: Option<String>,
6435 #[serde(rename = "CID")]
6436 #[serde(skip_serializing_if = "Option::is_none")]
6437 pub cid: Option<String>,
6439 #[serde(rename = "CPU")]
6440 #[serde(skip_serializing_if = "Option::is_none")]
6441 pub cpu: Option<String>,
6443 #[serde(rename = "Mem")]
6444 #[serde(skip_serializing_if = "Option::is_none")]
6445 pub mem: Option<String>,
6447 #[serde(rename = "MemUsage")]
6448 #[serde(skip_serializing_if = "Option::is_none")]
6449 pub mem_usage: Option<String>,
6451 #[serde(rename = "MemUsageBytes")]
6452 #[serde(skip_serializing_if = "Option::is_none")]
6453 pub mem_usage_bytes: Option<String>,
6455 #[serde(rename = "Name")]
6456 #[serde(skip_serializing_if = "Option::is_none")]
6457 pub name: Option<String>,
6459 #[serde(rename = "NetIO")]
6460 #[serde(skip_serializing_if = "Option::is_none")]
6461 pub net_io: Option<String>,
6463 #[serde(rename = "PIDS")]
6464 #[serde(skip_serializing_if = "Option::is_none")]
6465 pub pids: Option<String>,
6467 #[serde(rename = "Pod")]
6468 #[serde(skip_serializing_if = "Option::is_none")]
6469 pub pod: Option<String>,
6471}
6472
6473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6474pub struct PodStopReport {
6475 #[serde(rename = "Errs")]
6476 #[serde(skip_serializing_if = "Option::is_none")]
6477 pub errs: Option<Vec<String>>,
6478 #[serde(rename = "Id")]
6479 #[serde(skip_serializing_if = "Option::is_none")]
6480 pub id: Option<String>,
6481}
6482
6483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6484pub struct PodStorageConfig {
6485 #[serde(skip_serializing_if = "Option::is_none")]
6486 pub image_volumes: Option<Vec<ImageVolume>>,
6489 #[serde(skip_serializing_if = "Option::is_none")]
6490 pub mounts: Option<Vec<Mount>>,
6495 #[serde(skip_serializing_if = "Option::is_none")]
6496 pub overlay_volumes: Option<Vec<OverlayVolume>>,
6499 #[serde(skip_serializing_if = "Option::is_none")]
6500 pub shm_size: Option<i64>,
6504 #[serde(skip_serializing_if = "Option::is_none")]
6505 pub shm_size_systemd: Option<i64>,
6509 #[serde(skip_serializing_if = "Option::is_none")]
6510 pub volumes: Option<Vec<NamedVolume>>,
6515 #[serde(skip_serializing_if = "Option::is_none")]
6516 pub volumes_from: Option<Vec<String>>,
6522}
6523
6524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6525pub struct PodTopOkBody {
6526 #[serde(rename = "Processes")]
6527 #[serde(default)]
6528 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
6529 pub processes: Vec<Vec<String>>,
6532 #[serde(rename = "Titles")]
6533 #[serde(default)]
6534 #[serde(deserialize_with = "deserialize_nonoptional_vec")]
6535 pub titles: Vec<String>,
6537}
6538
6539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6540pub struct PodUnpauseReport {
6541 #[serde(rename = "Errs")]
6542 #[serde(skip_serializing_if = "Option::is_none")]
6543 pub errs: Option<Vec<String>>,
6544 #[serde(rename = "Id")]
6545 #[serde(skip_serializing_if = "Option::is_none")]
6546 pub id: Option<String>,
6547}
6548
6549#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6550pub struct Port {
6552 #[serde(rename = "IP")]
6553 #[serde(skip_serializing_if = "Option::is_none")]
6554 pub ip: Option<String>,
6556 #[serde(rename = "PrivatePort")]
6557 pub private_port: u16,
6559 #[serde(rename = "PublicPort")]
6560 #[serde(skip_serializing_if = "Option::is_none")]
6561 pub public_port: Option<u16>,
6563 #[serde(rename = "Type")]
6564 pub type_: String,
6566}
6567
6568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6569pub struct PortBinding {
6571 #[serde(rename = "HostIp")]
6572 #[serde(skip_serializing_if = "Option::is_none")]
6573 pub host_ip: Option<String>,
6575 #[serde(rename = "HostPort")]
6576 #[serde(skip_serializing_if = "Option::is_none")]
6577 pub host_port: Option<String>,
6579}
6580
6581pub type PortMap = HashMap<String, Option<Vec<PortBinding>>>;
6583
6584#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6585pub struct PortMapping {
6586 #[serde(skip_serializing_if = "Option::is_none")]
6587 pub container_port: Option<u16>,
6591 #[serde(skip_serializing_if = "Option::is_none")]
6592 pub host_ip: Option<String>,
6595 #[serde(skip_serializing_if = "Option::is_none")]
6596 pub host_port: Option<u16>,
6601 #[serde(skip_serializing_if = "Option::is_none")]
6602 pub protocol: Option<String>,
6607 #[serde(skip_serializing_if = "Option::is_none")]
6608 pub range: Option<u16>,
6617}
6618
6619pub type PortSet = HashMap<String, Value>;
6621
6622pub type Propagation = String;
6623
6624#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6625pub struct PruneReport {
6626 #[serde(rename = "Err")]
6627 #[serde(skip_serializing_if = "Option::is_none")]
6628 pub err: Option<String>,
6629 #[serde(rename = "Id")]
6630 #[serde(skip_serializing_if = "Option::is_none")]
6631 pub id: Option<String>,
6632 #[serde(rename = "Size")]
6633 #[serde(skip_serializing_if = "Option::is_none")]
6634 pub size: Option<u64>,
6635}
6636
6637pub type PublishState = String;
6640
6641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6642pub struct PublishStatus {
6645 #[serde(rename = "NodeID")]
6646 #[serde(skip_serializing_if = "Option::is_none")]
6647 pub node_id: Option<String>,
6649 #[serde(rename = "PublishContext")]
6650 #[serde(skip_serializing_if = "Option::is_none")]
6651 pub publish_context: Option<HashMap<String, String>>,
6654 #[serde(rename = "State")]
6655 pub state: Option<String>,
6656}
6657
6658pub type PutContainerArchiveLibpodRequestParam = String;
6659
6660pub type PutContainerArchiveRequestParam = String;
6661
6662#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6663pub struct Resources {
6665 #[serde(rename = "BlkioDeviceReadBps")]
6666 #[serde(skip_serializing_if = "Option::is_none")]
6667 pub blkio_device_read_bps: Option<Vec<ThrottleDevice>>,
6668 #[serde(rename = "BlkioDeviceReadIOps")]
6669 #[serde(skip_serializing_if = "Option::is_none")]
6670 pub blkio_device_read_i_ops: Option<Vec<ThrottleDevice>>,
6671 #[serde(rename = "BlkioDeviceWriteBps")]
6672 #[serde(skip_serializing_if = "Option::is_none")]
6673 pub blkio_device_write_bps: Option<Vec<ThrottleDevice>>,
6674 #[serde(rename = "BlkioDeviceWriteIOps")]
6675 #[serde(skip_serializing_if = "Option::is_none")]
6676 pub blkio_device_write_i_ops: Option<Vec<ThrottleDevice>>,
6677 #[serde(rename = "BlkioWeight")]
6678 #[serde(skip_serializing_if = "Option::is_none")]
6679 pub blkio_weight: Option<u16>,
6680 #[serde(rename = "BlkioWeightDevice")]
6681 #[serde(skip_serializing_if = "Option::is_none")]
6682 pub blkio_weight_device: Option<Vec<WeightDevice>>,
6683 #[serde(rename = "CgroupParent")]
6684 #[serde(skip_serializing_if = "Option::is_none")]
6685 pub cgroup_parent: Option<String>,
6687 #[serde(rename = "CpuCount")]
6688 #[serde(skip_serializing_if = "Option::is_none")]
6689 pub cpu_count: Option<i64>,
6691 #[serde(rename = "CpuPercent")]
6692 #[serde(skip_serializing_if = "Option::is_none")]
6693 pub cpu_percent: Option<i64>,
6694 #[serde(rename = "CpuPeriod")]
6695 #[serde(skip_serializing_if = "Option::is_none")]
6696 pub cpu_period: Option<i64>,
6697 #[serde(rename = "CpuQuota")]
6698 #[serde(skip_serializing_if = "Option::is_none")]
6699 pub cpu_quota: Option<i64>,
6700 #[serde(rename = "CpuRealtimePeriod")]
6701 #[serde(skip_serializing_if = "Option::is_none")]
6702 pub cpu_realtime_period: Option<i64>,
6703 #[serde(rename = "CpuRealtimeRuntime")]
6704 #[serde(skip_serializing_if = "Option::is_none")]
6705 pub cpu_realtime_runtime: Option<i64>,
6706 #[serde(rename = "CpuShares")]
6707 #[serde(skip_serializing_if = "Option::is_none")]
6708 pub cpu_shares: Option<i64>,
6710 #[serde(rename = "CpusetCpus")]
6711 #[serde(skip_serializing_if = "Option::is_none")]
6712 pub cpuset_cpus: Option<String>,
6713 #[serde(rename = "CpusetMems")]
6714 #[serde(skip_serializing_if = "Option::is_none")]
6715 pub cpuset_mems: Option<String>,
6716 #[serde(rename = "DeviceCgroupRules")]
6717 #[serde(skip_serializing_if = "Option::is_none")]
6718 pub device_cgroup_rules: Option<Vec<String>>,
6719 #[serde(rename = "DeviceRequests")]
6720 #[serde(skip_serializing_if = "Option::is_none")]
6721 pub device_requests: Option<Vec<DeviceRequest>>,
6722 #[serde(rename = "Devices")]
6723 #[serde(skip_serializing_if = "Option::is_none")]
6724 pub devices: Option<Vec<DeviceMapping>>,
6725 #[serde(rename = "IOMaximumBandwidth")]
6726 #[serde(skip_serializing_if = "Option::is_none")]
6727 pub io_maximum_bandwidth: Option<u64>,
6728 #[serde(rename = "IOMaximumIOps")]
6729 #[serde(skip_serializing_if = "Option::is_none")]
6730 pub io_maximum_i_ops: Option<u64>,
6731 #[serde(rename = "KernelMemory")]
6732 #[serde(skip_serializing_if = "Option::is_none")]
6733 pub kernel_memory: Option<i64>,
6736 #[serde(rename = "KernelMemoryTCP")]
6737 #[serde(skip_serializing_if = "Option::is_none")]
6738 pub kernel_memory_tcp: Option<i64>,
6739 #[serde(rename = "Memory")]
6740 #[serde(skip_serializing_if = "Option::is_none")]
6741 pub memory: Option<i64>,
6742 #[serde(rename = "MemoryReservation")]
6743 #[serde(skip_serializing_if = "Option::is_none")]
6744 pub memory_reservation: Option<i64>,
6745 #[serde(rename = "MemorySwap")]
6746 #[serde(skip_serializing_if = "Option::is_none")]
6747 pub memory_swap: Option<i64>,
6748 #[serde(rename = "MemorySwappiness")]
6749 #[serde(skip_serializing_if = "Option::is_none")]
6750 pub memory_swappiness: Option<i64>,
6751 #[serde(rename = "NanoCpus")]
6752 #[serde(skip_serializing_if = "Option::is_none")]
6753 pub nano_cpus: Option<i64>,
6754 #[serde(rename = "OomKillDisable")]
6755 #[serde(skip_serializing_if = "Option::is_none")]
6756 pub oom_kill_disable: Option<bool>,
6757 #[serde(rename = "PidsLimit")]
6758 #[serde(skip_serializing_if = "Option::is_none")]
6759 pub pids_limit: Option<i64>,
6760 #[serde(rename = "Ulimits")]
6761 #[serde(skip_serializing_if = "Option::is_none")]
6762 pub ulimits: Option<Vec<Ulimit>>,
6763}
6764
6765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6766pub struct RestartPolicy {
6767 #[serde(rename = "MaximumRetryCount")]
6768 #[serde(skip_serializing_if = "Option::is_none")]
6769 pub maximum_retry_count: Option<i64>,
6770 #[serde(rename = "Name")]
6771 #[serde(skip_serializing_if = "Option::is_none")]
6772 pub name: Option<String>,
6773}
6774
6775#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6776pub struct RootFs {
6777 #[serde(rename = "Layers")]
6778 #[serde(skip_serializing_if = "Option::is_none")]
6779 pub layers: Option<Vec<String>>,
6780 #[serde(rename = "Type")]
6781 #[serde(skip_serializing_if = "Option::is_none")]
6782 pub type_: Option<String>,
6783}
6784
6785#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6786pub struct Schema2HealthConfig {
6789 #[serde(rename = "Interval")]
6790 pub interval: Option<i64>,
6791 #[serde(rename = "Retries")]
6792 #[serde(skip_serializing_if = "Option::is_none")]
6793 pub retries: Option<i64>,
6796 #[serde(rename = "StartPeriod")]
6797 pub start_period: Option<i64>,
6798 #[serde(rename = "Test")]
6799 #[serde(skip_serializing_if = "Option::is_none")]
6800 pub test: Option<Vec<String>>,
6808 #[serde(rename = "Timeout")]
6809 pub timeout: Option<i64>,
6810}
6811
6812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6813pub struct Schema2ListPublic {
6816 #[serde(skip_serializing_if = "Option::is_none")]
6817 pub manifests: Option<Vec<Schema2ManifestDescriptor>>,
6818 #[serde(rename = "mediaType")]
6819 #[serde(skip_serializing_if = "Option::is_none")]
6820 pub media_type: Option<String>,
6821 #[serde(rename = "schemaVersion")]
6822 #[serde(skip_serializing_if = "Option::is_none")]
6823 pub schema_version: Option<i64>,
6824}
6825
6826#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6827pub struct Schema2ManifestDescriptor {
6829 pub digest: Option<String>,
6830 #[serde(rename = "mediaType")]
6831 #[serde(skip_serializing_if = "Option::is_none")]
6832 pub media_type: Option<String>,
6833 pub platform: Option<Schema2PlatformSpec>,
6834 #[serde(skip_serializing_if = "Option::is_none")]
6835 pub size: Option<i64>,
6836 #[serde(skip_serializing_if = "Option::is_none")]
6837 pub urls: Option<Vec<String>>,
6838}
6839
6840#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6841pub struct Schema2PlatformSpec {
6845 #[serde(skip_serializing_if = "Option::is_none")]
6846 pub architecture: Option<String>,
6847 #[serde(skip_serializing_if = "Option::is_none")]
6848 pub features: Option<Vec<String>>,
6849 #[serde(skip_serializing_if = "Option::is_none")]
6850 pub os: Option<String>,
6851 #[serde(rename = "os.features")]
6852 #[serde(skip_serializing_if = "Option::is_none")]
6853 pub os_features: Option<Vec<String>>,
6854 #[serde(rename = "os.version")]
6855 #[serde(skip_serializing_if = "Option::is_none")]
6856 pub os_version: Option<String>,
6857 #[serde(skip_serializing_if = "Option::is_none")]
6858 pub variant: Option<String>,
6859}
6860
6861pub type Scope = String;
6864
6865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6866pub struct ScpReport {
6867 #[serde(rename = "Id")]
6868 #[serde(skip_serializing_if = "Option::is_none")]
6869 pub id: Option<String>,
6870}
6871
6872#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6873pub struct Secret {
6877 #[serde(rename = "Key")]
6878 #[serde(skip_serializing_if = "Option::is_none")]
6879 pub key: Option<String>,
6881 #[serde(rename = "Secret")]
6882 #[serde(skip_serializing_if = "Option::is_none")]
6883 pub secret: Option<String>,
6887}
6888
6889#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6890pub struct SecretCreate {
6891 #[serde(rename = "Data")]
6892 #[serde(skip_serializing_if = "Option::is_none")]
6893 pub data: Option<String>,
6895 #[serde(rename = "Driver")]
6896 pub driver: Option<SecretDriverSpec>,
6897 #[serde(rename = "Labels")]
6898 #[serde(skip_serializing_if = "Option::is_none")]
6899 pub labels: Option<HashMap<String, String>>,
6901 #[serde(rename = "Name")]
6902 #[serde(skip_serializing_if = "Option::is_none")]
6903 pub name: Option<String>,
6905}
6906
6907pub type SecretCreateLibpodRequestParam = String;
6908
6909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6910pub struct SecretCreateReport {
6911 #[serde(rename = "ID")]
6912 #[serde(skip_serializing_if = "Option::is_none")]
6913 pub id: Option<String>,
6914}
6915
6916#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6917pub struct SecretCreateResponse {
6919 #[serde(rename = "ID")]
6920 #[serde(skip_serializing_if = "Option::is_none")]
6921 pub id: Option<String>,
6922}
6923
6924#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6925pub struct SecretDriverSpec {
6926 #[serde(rename = "Name")]
6927 #[serde(skip_serializing_if = "Option::is_none")]
6928 pub name: Option<String>,
6929 #[serde(rename = "Options")]
6930 #[serde(skip_serializing_if = "Option::is_none")]
6931 pub options: Option<HashMap<String, String>>,
6932}
6933
6934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6935pub struct SecretInUse {
6937 #[serde(skip_serializing_if = "Option::is_none")]
6938 pub cause: Option<String>,
6940 #[serde(skip_serializing_if = "Option::is_none")]
6941 pub message: Option<String>,
6943 #[serde(skip_serializing_if = "Option::is_none")]
6944 pub response: Option<i64>,
6946}
6947
6948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6949pub struct SecretInfoReport {
6950 #[serde(rename = "CreatedAt")]
6951 #[serde(skip_serializing_if = "Option::is_none")]
6952 pub created_at: Option<DateTime<Utc>>,
6953 #[serde(rename = "ID")]
6954 #[serde(skip_serializing_if = "Option::is_none")]
6955 pub id: Option<String>,
6956 #[serde(rename = "Spec")]
6957 pub spec: Option<SecretSpec>,
6958 #[serde(rename = "UpdatedAt")]
6959 #[serde(skip_serializing_if = "Option::is_none")]
6960 pub updated_at: Option<DateTime<Utc>>,
6961}
6962
6963#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6964pub struct SecretInfoReportCompat {
6965 #[serde(rename = "CreatedAt")]
6966 #[serde(skip_serializing_if = "Option::is_none")]
6967 pub created_at: Option<DateTime<Utc>>,
6968 #[serde(rename = "ID")]
6969 #[serde(skip_serializing_if = "Option::is_none")]
6970 pub id: Option<String>,
6971 #[serde(rename = "Spec")]
6972 pub spec: Option<SecretSpec>,
6973 #[serde(rename = "UpdatedAt")]
6974 #[serde(skip_serializing_if = "Option::is_none")]
6975 pub updated_at: Option<DateTime<Utc>>,
6976 #[serde(rename = "Version")]
6977 pub version: Option<SecretVersion>,
6978}
6979
6980pub type SecretListCompatResponse = Vec<SecretInfoReportCompat>;
6982
6983pub type SecretListResponse = Vec<SecretInfoReport>;
6985
6986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6987pub struct SecretRmReport {
6988 #[serde(rename = "Err")]
6989 #[serde(skip_serializing_if = "Option::is_none")]
6990 pub err: Option<String>,
6991 #[serde(rename = "ID")]
6992 #[serde(skip_serializing_if = "Option::is_none")]
6993 pub id: Option<String>,
6994}
6995
6996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6997pub struct SecretSpec {
6998 #[serde(rename = "Driver")]
6999 pub driver: Option<SecretDriverSpec>,
7000 #[serde(rename = "Labels")]
7001 #[serde(skip_serializing_if = "Option::is_none")]
7002 pub labels: Option<HashMap<String, String>>,
7003 #[serde(rename = "Name")]
7004 #[serde(skip_serializing_if = "Option::is_none")]
7005 pub name: Option<String>,
7006}
7007
7008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7009pub struct SecretVersion {
7010 #[serde(rename = "Index")]
7011 #[serde(skip_serializing_if = "Option::is_none")]
7012 pub index: Option<i64>,
7013}
7014
7015#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7016pub struct ServiceInfo {
7018 #[serde(rename = "LocalLBIndex")]
7019 #[serde(skip_serializing_if = "Option::is_none")]
7020 pub local_lb_index: Option<i64>,
7021 #[serde(rename = "Ports")]
7022 #[serde(skip_serializing_if = "Option::is_none")]
7023 pub ports: Option<Vec<String>>,
7024 #[serde(rename = "Tasks")]
7025 #[serde(skip_serializing_if = "Option::is_none")]
7026 pub tasks: Option<Vec<Task>>,
7027 #[serde(rename = "VIP")]
7028 #[serde(skip_serializing_if = "Option::is_none")]
7029 pub vip: Option<String>,
7030}
7031
7032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7033pub struct ServiceUpdateResponse {
7035 #[serde(rename = "Warnings")]
7036 #[serde(skip_serializing_if = "Option::is_none")]
7037 pub warnings: Option<Vec<String>>,
7039}
7040
7041pub type SharingMode = String;
7044
7045pub type Signal = i64;
7047
7048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7049pub struct SpecGenerator {
7052 #[serde(rename = "Networks")]
7053 #[serde(skip_serializing_if = "Option::is_none")]
7054 pub networks: Option<HashMap<String, PerNetworkOptions>>,
7061 #[serde(skip_serializing_if = "Option::is_none")]
7062 pub annotations: Option<HashMap<String, String>>,
7066 #[serde(skip_serializing_if = "Option::is_none")]
7067 pub apparmor_profile: Option<String>,
7071 #[serde(skip_serializing_if = "Option::is_none")]
7072 pub cap_add: Option<Vec<String>>,
7076 #[serde(skip_serializing_if = "Option::is_none")]
7077 pub cap_drop: Option<Vec<String>>,
7081 #[serde(skip_serializing_if = "Option::is_none")]
7082 pub cgroup_parent: Option<String>,
7086 pub cgroupns: Option<Namespace>,
7087 #[serde(skip_serializing_if = "Option::is_none")]
7088 pub cgroups_mode: Option<String>,
7091 #[serde(skip_serializing_if = "Option::is_none")]
7092 pub chroot_directories: Option<Vec<String>>,
7096 #[serde(skip_serializing_if = "Option::is_none")]
7097 pub cni_networks: Option<Vec<String>>,
7105 #[serde(skip_serializing_if = "Option::is_none")]
7106 pub command: Option<Vec<String>>,
7111 #[serde(skip_serializing_if = "Option::is_none")]
7112 pub conmon_pid_file: Option<String>,
7117 #[serde(rename = "containerCreateCommand")]
7118 #[serde(skip_serializing_if = "Option::is_none")]
7119 pub container_create_command: Option<Vec<String>>,
7126 #[serde(skip_serializing_if = "Option::is_none")]
7127 pub cpu_period: Option<u64>,
7129 #[serde(skip_serializing_if = "Option::is_none")]
7130 pub cpu_quota: Option<i64>,
7132 #[serde(skip_serializing_if = "Option::is_none")]
7133 pub create_working_dir: Option<bool>,
7137 #[serde(rename = "dependencyContainers")]
7138 #[serde(skip_serializing_if = "Option::is_none")]
7139 pub dependency_containers: Option<Vec<String>>,
7144 #[serde(skip_serializing_if = "Option::is_none")]
7145 pub device_cgroup_rule: Option<Vec<LinuxDeviceCgroup>>,
7148 #[serde(skip_serializing_if = "Option::is_none")]
7149 pub devices: Option<Vec<LinuxDevice>>,
7152 #[serde(skip_serializing_if = "Option::is_none")]
7153 pub devices_from: Option<Vec<String>>,
7155 #[serde(skip_serializing_if = "Option::is_none")]
7156 pub dns_option: Option<Vec<String>>,
7162 #[serde(skip_serializing_if = "Option::is_none")]
7163 pub dns_search: Option<Vec<String>>,
7169 #[serde(skip_serializing_if = "Option::is_none")]
7170 pub dns_server: Option<Vec<String>>,
7176 #[serde(skip_serializing_if = "Option::is_none")]
7177 pub entrypoint: Option<Vec<String>>,
7182 #[serde(skip_serializing_if = "Option::is_none")]
7183 pub env: Option<HashMap<String, String>>,
7187 #[serde(skip_serializing_if = "Option::is_none")]
7188 pub env_host: Option<bool>,
7191 #[serde(skip_serializing_if = "Option::is_none")]
7192 pub envmerge: Option<Vec<String>>,
7195 #[serde(skip_serializing_if = "Option::is_none")]
7196 pub expose: Option<Value>,
7206 #[serde(skip_serializing_if = "Option::is_none")]
7207 pub group_entry: Option<String>,
7209 #[serde(skip_serializing_if = "Option::is_none")]
7210 pub groups: Option<Vec<String>>,
7214 pub health_check_on_failure_action: Option<i64>,
7215 pub healthconfig: Option<Schema2HealthConfig>,
7216 #[serde(skip_serializing_if = "Option::is_none")]
7217 pub host_device_list: Option<Vec<LinuxDevice>>,
7219 #[serde(skip_serializing_if = "Option::is_none")]
7220 pub hostadd: Option<Vec<String>>,
7225 #[serde(skip_serializing_if = "Option::is_none")]
7226 pub hostname: Option<String>,
7232 #[serde(skip_serializing_if = "Option::is_none")]
7233 pub hostusers: Option<Vec<String>>,
7236 #[serde(skip_serializing_if = "Option::is_none")]
7237 pub httpproxy: Option<bool>,
7241 pub idmappings: Option<IdMappingOptions>,
7242 #[serde(skip_serializing_if = "Option::is_none")]
7243 pub image: Option<String>,
7249 #[serde(skip_serializing_if = "Option::is_none")]
7250 pub image_arch: Option<String>,
7252 #[serde(skip_serializing_if = "Option::is_none")]
7253 pub image_os: Option<String>,
7255 #[serde(skip_serializing_if = "Option::is_none")]
7256 pub image_variant: Option<String>,
7258 #[serde(skip_serializing_if = "Option::is_none")]
7259 pub image_volume_mode: Option<String>,
7265 #[serde(skip_serializing_if = "Option::is_none")]
7266 pub image_volumes: Option<Vec<ImageVolume>>,
7269 #[serde(skip_serializing_if = "Option::is_none")]
7270 pub init: Option<bool>,
7273 #[serde(skip_serializing_if = "Option::is_none")]
7274 pub init_container_type: Option<String>,
7277 #[serde(skip_serializing_if = "Option::is_none")]
7278 pub init_path: Option<String>,
7283 pub ipcns: Option<Namespace>,
7284 #[serde(skip_serializing_if = "Option::is_none")]
7285 pub label_nested: Option<bool>,
7288 #[serde(skip_serializing_if = "Option::is_none")]
7289 pub labels: Option<HashMap<String, String>>,
7293 pub log_configuration: Option<LogConfigLibpod>,
7294 #[serde(skip_serializing_if = "Option::is_none")]
7295 pub manage_password: Option<bool>,
7297 #[serde(skip_serializing_if = "Option::is_none")]
7298 pub mask: Option<Vec<String>>,
7302 #[serde(skip_serializing_if = "Option::is_none")]
7303 pub mounts: Option<Vec<Mount>>,
7308 #[serde(skip_serializing_if = "Option::is_none")]
7309 pub name: Option<String>,
7313 #[serde(skip_serializing_if = "Option::is_none")]
7314 pub namespace: Option<String>,
7317 pub netns: Option<Namespace>,
7318 #[serde(skip_serializing_if = "Option::is_none")]
7319 pub network_options: Option<HashMap<String, Vec<String>>>,
7322 #[serde(skip_serializing_if = "Option::is_none")]
7323 pub no_new_privileges: Option<bool>,
7327 #[serde(skip_serializing_if = "Option::is_none")]
7328 pub oci_runtime: Option<String>,
7333 #[serde(skip_serializing_if = "Option::is_none")]
7334 pub oom_score_adj: Option<i64>,
7338 #[serde(skip_serializing_if = "Option::is_none")]
7339 pub overlay_volumes: Option<Vec<OverlayVolume>>,
7342 #[serde(skip_serializing_if = "Option::is_none")]
7343 pub passwd_entry: Option<String>,
7345 pub personality: Option<LinuxPersonality>,
7346 pub pidns: Option<Namespace>,
7347 #[serde(skip_serializing_if = "Option::is_none")]
7348 pub pod: Option<String>,
7351 #[serde(skip_serializing_if = "Option::is_none")]
7352 pub portmappings: Option<Vec<PortMapping>>,
7356 #[serde(skip_serializing_if = "Option::is_none")]
7357 pub privileged: Option<bool>,
7366 #[serde(skip_serializing_if = "Option::is_none")]
7367 pub procfs_opts: Option<Vec<String>>,
7369 #[serde(skip_serializing_if = "Option::is_none")]
7370 pub publish_image_ports: Option<bool>,
7376 #[serde(skip_serializing_if = "Option::is_none")]
7377 pub r_limits: Option<Vec<PosixRlimit>>,
7380 #[serde(skip_serializing_if = "Option::is_none")]
7381 pub raw_image_name: Option<String>,
7384 #[serde(skip_serializing_if = "Option::is_none")]
7385 pub read_only_filesystem: Option<bool>,
7388 #[serde(skip_serializing_if = "Option::is_none")]
7389 pub read_write_tmpfs: Option<bool>,
7392 #[serde(skip_serializing_if = "Option::is_none")]
7393 pub remove: Option<bool>,
7396 pub resource_limits: Option<LinuxResources>,
7397 #[serde(skip_serializing_if = "Option::is_none")]
7398 pub restart_policy: Option<String>,
7403 #[serde(skip_serializing_if = "Option::is_none")]
7404 pub restart_tries: Option<u64>,
7409 #[serde(skip_serializing_if = "Option::is_none")]
7410 pub rootfs: Option<String>,
7416 #[serde(skip_serializing_if = "Option::is_none")]
7417 pub rootfs_mapping: Option<String>,
7419 #[serde(skip_serializing_if = "Option::is_none")]
7420 pub rootfs_overlay: Option<bool>,
7422 #[serde(skip_serializing_if = "Option::is_none")]
7423 pub rootfs_propagation: Option<String>,
7427 #[serde(rename = "sdnotifyMode")]
7428 #[serde(skip_serializing_if = "Option::is_none")]
7429 pub sdnotify_mode: Option<String>,
7434 #[serde(skip_serializing_if = "Option::is_none")]
7435 pub seccomp_policy: Option<String>,
7438 #[serde(skip_serializing_if = "Option::is_none")]
7439 pub seccomp_profile_path: Option<String>,
7444 #[serde(skip_serializing_if = "Option::is_none")]
7445 pub secret_env: Option<HashMap<String, String>>,
7448 #[serde(skip_serializing_if = "Option::is_none")]
7449 pub secrets: Option<Vec<Secret>>,
7452 #[serde(skip_serializing_if = "Option::is_none")]
7453 pub selinux_opts: Option<Vec<String>>,
7458 #[serde(skip_serializing_if = "Option::is_none")]
7459 pub shm_size: Option<i64>,
7463 #[serde(skip_serializing_if = "Option::is_none")]
7464 pub shm_size_systemd: Option<i64>,
7468 #[serde(rename = "startupHealthConfig")]
7469 pub startup_health_config: Option<StartupHealthCheck>,
7470 #[serde(skip_serializing_if = "Option::is_none")]
7471 pub stdin: Option<bool>,
7473 pub stop_signal: Option<i64>,
7474 #[serde(skip_serializing_if = "Option::is_none")]
7475 pub stop_timeout: Option<u64>,
7482 #[serde(skip_serializing_if = "Option::is_none")]
7483 pub storage_opts: Option<HashMap<String, String>>,
7486 #[serde(skip_serializing_if = "Option::is_none")]
7487 pub sysctl: Option<HashMap<String, String>>,
7489 #[serde(skip_serializing_if = "Option::is_none")]
7490 pub systemd: Option<String>,
7501 #[serde(skip_serializing_if = "Option::is_none")]
7502 pub terminal: Option<bool>,
7505 #[serde(rename = "throttleReadBpsDevice")]
7506 #[serde(skip_serializing_if = "Option::is_none")]
7507 pub throttle_read_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
7509 #[serde(rename = "throttleReadIOPSDevice")]
7510 #[serde(skip_serializing_if = "Option::is_none")]
7511 pub throttle_read_iops_device: Option<HashMap<String, LinuxThrottleDevice>>,
7513 #[serde(rename = "throttleWriteBpsDevice")]
7514 #[serde(skip_serializing_if = "Option::is_none")]
7515 pub throttle_write_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
7517 #[serde(rename = "throttleWriteIOPSDevice")]
7518 #[serde(skip_serializing_if = "Option::is_none")]
7519 pub throttle_write_iops_device: Option<HashMap<String, LinuxThrottleDevice>>,
7521 #[serde(skip_serializing_if = "Option::is_none")]
7522 pub timeout: Option<u64>,
7527 #[serde(skip_serializing_if = "Option::is_none")]
7528 pub timezone: Option<String>,
7532 #[serde(skip_serializing_if = "Option::is_none")]
7533 pub umask: Option<String>,
7535 #[serde(skip_serializing_if = "Option::is_none")]
7536 pub unified: Option<HashMap<String, String>>,
7540 #[serde(skip_serializing_if = "Option::is_none")]
7541 pub unmask: Option<Vec<String>>,
7544 #[serde(skip_serializing_if = "Option::is_none")]
7545 pub unsetenv: Option<Vec<String>>,
7548 #[serde(skip_serializing_if = "Option::is_none")]
7549 pub unsetenvall: Option<bool>,
7553 #[serde(skip_serializing_if = "Option::is_none")]
7554 pub use_image_hosts: Option<bool>,
7564 #[serde(skip_serializing_if = "Option::is_none")]
7565 pub use_image_resolve_conf: Option<bool>,
7569 #[serde(skip_serializing_if = "Option::is_none")]
7570 pub user: Option<String>,
7576 pub userns: Option<Namespace>,
7577 pub utsns: Option<Namespace>,
7578 #[serde(skip_serializing_if = "Option::is_none")]
7579 pub volatile: Option<bool>,
7582 #[serde(skip_serializing_if = "Option::is_none")]
7583 pub volumes: Option<Vec<NamedVolume>>,
7588 #[serde(skip_serializing_if = "Option::is_none")]
7589 pub volumes_from: Option<Vec<String>>,
7595 #[serde(rename = "weightDevice")]
7596 #[serde(skip_serializing_if = "Option::is_none")]
7597 pub weight_device: Option<HashMap<String, LinuxWeightDevice>>,
7599 #[serde(skip_serializing_if = "Option::is_none")]
7600 pub work_dir: Option<String>,
7604}
7605
7606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7607pub struct StartupHealthCheck {
7608 #[serde(rename = "Interval")]
7609 pub interval: Option<i64>,
7610 #[serde(rename = "Retries")]
7611 #[serde(skip_serializing_if = "Option::is_none")]
7612 pub retries: Option<i64>,
7615 #[serde(rename = "StartPeriod")]
7616 pub start_period: Option<i64>,
7617 #[serde(rename = "Successes")]
7618 #[serde(skip_serializing_if = "Option::is_none")]
7619 pub successes: Option<i64>,
7623 #[serde(rename = "Test")]
7624 #[serde(skip_serializing_if = "Option::is_none")]
7625 pub test: Option<Vec<String>>,
7633 #[serde(rename = "Timeout")]
7634 pub timeout: Option<i64>,
7635}
7636
7637pub type StrSlice = Vec<String>;
7639
7640#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7641pub struct Subnet {
7642 #[serde(skip_serializing_if = "Option::is_none")]
7643 pub gateway: Option<String>,
7645 pub lease_range: Option<LeaseRange>,
7646 #[serde(skip_serializing_if = "Option::is_none")]
7647 pub subnet: Option<String>,
7649}
7650
7651#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7652pub struct SummaryNetworkSettings {
7655 #[serde(rename = "Networks")]
7656 #[serde(skip_serializing_if = "Option::is_none")]
7657 pub networks: Option<HashMap<String, EndpointSettings>>,
7658}
7659
7660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7661pub struct SystemDfContainerReport {
7663 #[serde(rename = "Command")]
7664 #[serde(skip_serializing_if = "Option::is_none")]
7665 pub command: Option<Vec<String>>,
7666 #[serde(rename = "ContainerID")]
7667 #[serde(skip_serializing_if = "Option::is_none")]
7668 pub container_id: Option<String>,
7669 #[serde(rename = "Created")]
7670 #[serde(skip_serializing_if = "Option::is_none")]
7671 pub created: Option<DateTime<Utc>>,
7672 #[serde(rename = "Image")]
7673 #[serde(skip_serializing_if = "Option::is_none")]
7674 pub image: Option<String>,
7675 #[serde(rename = "LocalVolumes")]
7676 #[serde(skip_serializing_if = "Option::is_none")]
7677 pub local_volumes: Option<i64>,
7678 #[serde(rename = "Names")]
7679 #[serde(skip_serializing_if = "Option::is_none")]
7680 pub names: Option<String>,
7681 #[serde(rename = "RWSize")]
7682 #[serde(skip_serializing_if = "Option::is_none")]
7683 pub rw_size: Option<i64>,
7684 #[serde(rename = "Size")]
7685 #[serde(skip_serializing_if = "Option::is_none")]
7686 pub size: Option<i64>,
7687 #[serde(rename = "Status")]
7688 #[serde(skip_serializing_if = "Option::is_none")]
7689 pub status: Option<String>,
7690}
7691
7692#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7693pub struct SystemDfImageReport {
7695 #[serde(rename = "Containers")]
7696 #[serde(skip_serializing_if = "Option::is_none")]
7697 pub containers: Option<i64>,
7698 #[serde(rename = "Created")]
7699 #[serde(skip_serializing_if = "Option::is_none")]
7700 pub created: Option<DateTime<Utc>>,
7701 #[serde(rename = "ImageID")]
7702 #[serde(skip_serializing_if = "Option::is_none")]
7703 pub image_id: Option<String>,
7704 #[serde(rename = "Repository")]
7705 #[serde(skip_serializing_if = "Option::is_none")]
7706 pub repository: Option<String>,
7707 #[serde(rename = "SharedSize")]
7708 #[serde(skip_serializing_if = "Option::is_none")]
7709 pub shared_size: Option<i64>,
7710 #[serde(rename = "Size")]
7711 #[serde(skip_serializing_if = "Option::is_none")]
7712 pub size: Option<i64>,
7713 #[serde(rename = "Tag")]
7714 #[serde(skip_serializing_if = "Option::is_none")]
7715 pub tag: Option<String>,
7716 #[serde(rename = "UniqueSize")]
7717 #[serde(skip_serializing_if = "Option::is_none")]
7718 pub unique_size: Option<i64>,
7719}
7720
7721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7722pub struct SystemDfReport {
7724 #[serde(rename = "Containers")]
7725 #[serde(skip_serializing_if = "Option::is_none")]
7726 pub containers: Option<Vec<SystemDfContainerReport>>,
7727 #[serde(rename = "Images")]
7728 #[serde(skip_serializing_if = "Option::is_none")]
7729 pub images: Option<Vec<SystemDfImageReport>>,
7730 #[serde(rename = "ImagesSize")]
7731 #[serde(skip_serializing_if = "Option::is_none")]
7732 pub images_size: Option<i64>,
7733 #[serde(rename = "Volumes")]
7734 #[serde(skip_serializing_if = "Option::is_none")]
7735 pub volumes: Option<Vec<SystemDfVolumeReport>>,
7736}
7737
7738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7739pub struct SystemDfVolumeReport {
7741 #[serde(rename = "Links")]
7742 #[serde(skip_serializing_if = "Option::is_none")]
7743 pub links: Option<i64>,
7744 #[serde(rename = "ReclaimableSize")]
7745 #[serde(skip_serializing_if = "Option::is_none")]
7746 pub reclaimable_size: Option<i64>,
7747 #[serde(rename = "Size")]
7748 #[serde(skip_serializing_if = "Option::is_none")]
7749 pub size: Option<i64>,
7750 #[serde(rename = "VolumeName")]
7751 #[serde(skip_serializing_if = "Option::is_none")]
7752 pub volume_name: Option<String>,
7753}
7754
7755pub type SystemPing200Response = String;
7757
7758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7759pub struct SystemPruneReport {
7760 #[serde(rename = "ContainerPruneReports")]
7761 #[serde(skip_serializing_if = "Option::is_none")]
7762 pub container_prune_reports: Option<Vec<PruneReport>>,
7763 #[serde(rename = "ImagePruneReports")]
7764 #[serde(skip_serializing_if = "Option::is_none")]
7765 pub image_prune_reports: Option<Vec<PruneReport>>,
7766 #[serde(rename = "NetworkPruneReports")]
7767 #[serde(skip_serializing_if = "Option::is_none")]
7768 pub network_prune_reports: Option<Vec<NetworkPruneReport>>,
7769 #[serde(rename = "PodPruneReport")]
7770 #[serde(skip_serializing_if = "Option::is_none")]
7771 pub pod_prune_report: Option<Vec<PodPruneReport>>,
7772 #[serde(rename = "ReclaimedSpace")]
7773 #[serde(skip_serializing_if = "Option::is_none")]
7774 pub reclaimed_space: Option<u64>,
7775 #[serde(rename = "VolumePruneReports")]
7776 #[serde(skip_serializing_if = "Option::is_none")]
7777 pub volume_prune_reports: Option<Vec<PruneReport>>,
7778}
7779
7780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7781pub struct Task {
7783 #[serde(rename = "EndpointID")]
7784 #[serde(skip_serializing_if = "Option::is_none")]
7785 pub endpoint_id: Option<String>,
7786 #[serde(rename = "EndpointIP")]
7787 #[serde(skip_serializing_if = "Option::is_none")]
7788 pub endpoint_ip: Option<String>,
7789 #[serde(rename = "Info")]
7790 #[serde(skip_serializing_if = "Option::is_none")]
7791 pub info: Option<HashMap<String, String>>,
7792 #[serde(rename = "Name")]
7793 #[serde(skip_serializing_if = "Option::is_none")]
7794 pub name: Option<String>,
7795}
7796
7797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7798pub struct ThrottleDevice {
7800 #[serde(rename = "Path")]
7801 #[serde(skip_serializing_if = "Option::is_none")]
7802 pub path: Option<String>,
7803 #[serde(rename = "Rate")]
7804 #[serde(skip_serializing_if = "Option::is_none")]
7805 pub rate: Option<u64>,
7806}
7807
7808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7809pub struct TmpfsOptions {
7810 #[serde(rename = "Mode")]
7811 pub mode: Option<u32>,
7812 #[serde(rename = "SizeBytes")]
7813 #[serde(skip_serializing_if = "Option::is_none")]
7814 pub size_bytes: Option<i64>,
7823}
7824
7825#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7826pub struct Topology {
7857 #[serde(rename = "Segments")]
7858 #[serde(skip_serializing_if = "Option::is_none")]
7859 pub segments: Option<HashMap<String, String>>,
7860}
7861
7862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7863pub struct TopologyRequirement {
7866 #[serde(rename = "Preferred")]
7867 #[serde(skip_serializing_if = "Option::is_none")]
7868 pub preferred: Option<Vec<Topology>>,
7943 #[serde(rename = "Requisite")]
7944 #[serde(skip_serializing_if = "Option::is_none")]
7945 pub requisite: Option<Vec<Topology>>,
8007}
8008
8009pub type Type = String;
8010
8011pub type TypeBlock = Value;
8013
8014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8015pub struct TypeMount {
8018 #[serde(rename = "FsType")]
8019 #[serde(skip_serializing_if = "Option::is_none")]
8020 pub fs_type: Option<String>,
8022 #[serde(rename = "MountFlags")]
8023 #[serde(skip_serializing_if = "Option::is_none")]
8024 pub mount_flags: Option<Vec<String>>,
8026}
8027
8028pub type UtsMode = String;
8029
8030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8031pub struct Ulimit {
8032 #[serde(rename = "Hard")]
8033 #[serde(skip_serializing_if = "Option::is_none")]
8034 pub hard: Option<i64>,
8035 #[serde(rename = "Name")]
8036 #[serde(skip_serializing_if = "Option::is_none")]
8037 pub name: Option<String>,
8038 #[serde(rename = "Soft")]
8039 #[serde(skip_serializing_if = "Option::is_none")]
8040 pub soft: Option<i64>,
8041}
8042
8043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8044pub struct UpdateEntities {
8046 #[serde(rename = "Resources")]
8047 pub resources: Option<LinuxResources>,
8048}
8049
8050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8051pub struct UsageData {
8054 #[serde(rename = "RefCount")]
8055 pub ref_count: i64,
8058 #[serde(rename = "Size")]
8059 pub size: i64,
8064}
8065
8066pub type UsernsMode = String;
8067
8068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8069pub struct Version {
8070 #[serde(rename = "Index")]
8071 #[serde(skip_serializing_if = "Option::is_none")]
8072 pub index: Option<u64>,
8073}
8074
8075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8076pub struct Volume {
8078 #[serde(rename = "ClusterVolume")]
8079 pub cluster_volume: Option<ClusterVolume>,
8080 #[serde(rename = "CreatedAt")]
8081 #[serde(skip_serializing_if = "Option::is_none")]
8082 pub created_at: Option<String>,
8084 #[serde(rename = "Driver")]
8085 pub driver: String,
8087 #[serde(rename = "Labels")]
8088 #[serde(default)]
8089 #[serde(deserialize_with = "deserialize_nonoptional_map")]
8090 pub labels: HashMap<String, String>,
8092 #[serde(rename = "Mountpoint")]
8093 pub mountpoint: String,
8095 #[serde(rename = "Name")]
8096 pub name: String,
8098 #[serde(rename = "Options")]
8099 #[serde(default)]
8100 #[serde(deserialize_with = "deserialize_nonoptional_map")]
8101 pub options: HashMap<String, String>,
8103 #[serde(rename = "Scope")]
8104 pub scope: String,
8107 #[serde(rename = "Status")]
8108 #[serde(skip_serializing_if = "Option::is_none")]
8109 pub status: Option<Value>,
8116 #[serde(rename = "UsageData")]
8117 pub usage_data: Option<UsageData>,
8118}
8119
8120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8121pub struct VolumeConfigResponse {
8122 #[serde(rename = "Anonymous")]
8123 #[serde(skip_serializing_if = "Option::is_none")]
8124 pub anonymous: Option<bool>,
8128 #[serde(rename = "CreatedAt")]
8129 #[serde(skip_serializing_if = "Option::is_none")]
8130 pub created_at: Option<DateTime<Utc>>,
8133 #[serde(rename = "Driver")]
8134 #[serde(skip_serializing_if = "Option::is_none")]
8135 pub driver: Option<String>,
8140 #[serde(rename = "GID")]
8141 #[serde(skip_serializing_if = "Option::is_none")]
8142 pub gid: Option<i64>,
8144 #[serde(rename = "Labels")]
8145 #[serde(skip_serializing_if = "Option::is_none")]
8146 pub labels: Option<HashMap<String, String>>,
8150 #[serde(rename = "MountCount")]
8151 #[serde(skip_serializing_if = "Option::is_none")]
8152 pub mount_count: Option<u64>,
8154 #[serde(rename = "Mountpoint")]
8155 #[serde(skip_serializing_if = "Option::is_none")]
8156 pub mountpoint: Option<String>,
8158 #[serde(rename = "Name")]
8159 #[serde(skip_serializing_if = "Option::is_none")]
8160 pub name: Option<String>,
8162 #[serde(rename = "NeedsChown")]
8163 #[serde(skip_serializing_if = "Option::is_none")]
8164 pub needs_chown: Option<bool>,
8168 #[serde(rename = "NeedsCopyUp")]
8169 #[serde(skip_serializing_if = "Option::is_none")]
8170 pub needs_copy_up: Option<bool>,
8172 #[serde(rename = "Options")]
8173 #[serde(skip_serializing_if = "Option::is_none")]
8174 pub options: Option<HashMap<String, String>>,
8181 #[serde(rename = "Scope")]
8182 #[serde(skip_serializing_if = "Option::is_none")]
8183 pub scope: Option<String>,
8186 #[serde(rename = "Status")]
8187 #[serde(skip_serializing_if = "Option::is_none")]
8188 pub status: Option<Value>,
8195 #[serde(rename = "StorageID")]
8196 #[serde(skip_serializing_if = "Option::is_none")]
8197 pub storage_id: Option<String>,
8200 #[serde(rename = "Timeout")]
8201 #[serde(skip_serializing_if = "Option::is_none")]
8202 pub timeout: Option<u64>,
8204 #[serde(rename = "UID")]
8205 #[serde(skip_serializing_if = "Option::is_none")]
8206 pub uid: Option<i64>,
8208}
8209
8210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8211pub struct VolumeCreateOptions {
8213 #[serde(rename = "Driver")]
8214 #[serde(skip_serializing_if = "Option::is_none")]
8215 pub driver: Option<String>,
8217 #[serde(rename = "IgnoreIfExists")]
8218 #[serde(skip_serializing_if = "Option::is_none")]
8219 pub ignore_if_exists: Option<bool>,
8221 #[serde(rename = "Label")]
8222 #[serde(skip_serializing_if = "Option::is_none")]
8223 pub label: Option<HashMap<String, String>>,
8225 #[serde(rename = "Labels")]
8226 #[serde(skip_serializing_if = "Option::is_none")]
8227 pub labels: Option<HashMap<String, String>>,
8229 #[serde(rename = "Name")]
8230 #[serde(skip_serializing_if = "Option::is_none")]
8231 pub name: Option<String>,
8233 #[serde(rename = "Options")]
8234 #[serde(skip_serializing_if = "Option::is_none")]
8235 pub options: Option<HashMap<String, String>>,
8237}
8238
8239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8240pub struct VolumeOptions {
8241 #[serde(rename = "DriverConfig")]
8242 pub driver_config: Option<Driver>,
8243 #[serde(rename = "Labels")]
8244 #[serde(skip_serializing_if = "Option::is_none")]
8245 pub labels: Option<HashMap<String, String>>,
8246 #[serde(rename = "NoCopy")]
8247 #[serde(skip_serializing_if = "Option::is_none")]
8248 pub no_copy: Option<bool>,
8249}
8250
8251#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8252pub struct VolumeRmReport {
8253 #[serde(rename = "Err")]
8254 #[serde(skip_serializing_if = "Option::is_none")]
8255 pub err: Option<String>,
8256 #[serde(rename = "Id")]
8257 #[serde(skip_serializing_if = "Option::is_none")]
8258 pub id: Option<String>,
8259}
8260
8261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8262pub struct VolumesPruneReport {
8264 #[serde(rename = "SpaceReclaimed")]
8265 #[serde(skip_serializing_if = "Option::is_none")]
8266 pub space_reclaimed: Option<u64>,
8267 #[serde(rename = "VolumesDeleted")]
8268 #[serde(skip_serializing_if = "Option::is_none")]
8269 pub volumes_deleted: Option<Vec<String>>,
8270}
8271
8272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8273pub struct WaitExitError {
8275 #[serde(rename = "Message")]
8276 #[serde(skip_serializing_if = "Option::is_none")]
8277 pub message: Option<String>,
8279}
8280
8281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8282pub struct WaitResponse {
8284 #[serde(rename = "Error")]
8285 pub error: Option<WaitExitError>,
8286 #[serde(rename = "StatusCode")]
8287 pub status_code: i64,
8289}
8290
8291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8292pub struct WeightDevice {
8294 #[serde(rename = "Path")]
8295 #[serde(skip_serializing_if = "Option::is_none")]
8296 pub path: Option<String>,
8297 #[serde(rename = "Weight")]
8298 #[serde(skip_serializing_if = "Option::is_none")]
8299 pub weight: Option<u16>,
8300}
8301
8302pub type ContainerRemoveLibpod = Vec<LibpodContainersRmReport>;
8304
8305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8306pub struct ContainerWaitResponse {
8308 #[serde(rename = "Error")]
8309 #[serde(skip_serializing_if = "Option::is_none")]
8310 pub error: Option<ContainerWaitResponseErrorInlineItem>,
8311 #[serde(rename = "StatusCode")]
8312 #[serde(skip_serializing_if = "Option::is_none")]
8313 pub status_code: Option<i64>,
8315}
8316
8317#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8318pub struct ContainerWaitResponseErrorInlineItem {
8319 #[serde(rename = "Message")]
8320 #[serde(skip_serializing_if = "Option::is_none")]
8321 pub message: Option<String>,
8322}
8323
8324pub type ContainersList = Vec<Container>;
8326
8327pub type ContainersListLibpod = Vec<ListContainer>;
8329
8330pub type ContainersPrune = Vec<ContainersPruneReport>;
8332
8333pub type ContainersPruneLibpod = Vec<ContainersPruneReportLibpod>;
8335
8336pub type ImageDeleteResponse = Vec<ImageDeleteResponseInlineItem>;
8338
8339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8340pub struct ImageDeleteResponseInlineItem {
8341 #[serde(skip_serializing_if = "Option::is_none")]
8342 pub deleted: Option<String>,
8343 #[serde(skip_serializing_if = "Option::is_none")]
8344 pub untagged: Option<Vec<String>>,
8345}
8346
8347pub type ImageList = Vec<ImageSummary>;
8349
8350pub type ImageListLibpod = Vec<LibpodImageSummary>;
8352
8353pub type ImagesPruneLibpod = Vec<PruneReport>;
8355
8356#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8357pub struct NetworkCreateLibpod {
8359 #[serde(skip_serializing_if = "Option::is_none")]
8360 pub created: Option<DateTime<Utc>>,
8362 #[serde(skip_serializing_if = "Option::is_none")]
8363 pub dns_enabled: Option<bool>,
8366 #[serde(skip_serializing_if = "Option::is_none")]
8367 pub driver: Option<String>,
8369 #[serde(skip_serializing_if = "Option::is_none")]
8370 pub id: Option<String>,
8372 #[serde(skip_serializing_if = "Option::is_none")]
8373 pub internal: Option<bool>,
8376 #[serde(skip_serializing_if = "Option::is_none")]
8377 pub ipam_options: Option<HashMap<String, String>>,
8379 #[serde(rename = "ipv6_enabled")]
8380 #[serde(skip_serializing_if = "Option::is_none")]
8381 pub ipv_6_enabled: Option<bool>,
8383 #[serde(skip_serializing_if = "Option::is_none")]
8384 pub labels: Option<HashMap<String, String>>,
8387 #[serde(skip_serializing_if = "Option::is_none")]
8388 pub name: Option<String>,
8390 #[serde(skip_serializing_if = "Option::is_none")]
8391 pub network_dns_servers: Option<Vec<String>>,
8395 #[serde(skip_serializing_if = "Option::is_none")]
8396 pub network_interface: Option<String>,
8398 #[serde(skip_serializing_if = "Option::is_none")]
8399 pub options: Option<HashMap<String, String>>,
8402 #[serde(skip_serializing_if = "Option::is_none")]
8403 pub subnets: Option<Vec<Subnet>>,
8405}
8406
8407pub type NetworkListCompat = Vec<NetworkResource>;
8409
8410pub type NetworkListLibpod = Vec<Network>;
8412
8413pub type NetworkPruneResponse = Vec<NetworkPruneReport>;
8415
8416pub type NetworkRmResponse = Vec<NetworkRmReport>;
8418
8419pub type Ok = Value;
8421
8422pub type PodStatsResponse = Vec<PodStatsReport>;
8424
8425pub type PodsListResponse = Vec<ListPodsReport>;
8427
8428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8429pub struct RegistrySearchResponse {
8431 #[serde(rename = "Automated")]
8432 #[serde(skip_serializing_if = "Option::is_none")]
8433 pub automated: Option<String>,
8435 #[serde(rename = "Description")]
8436 #[serde(skip_serializing_if = "Option::is_none")]
8437 pub description: Option<String>,
8439 #[serde(rename = "Index")]
8440 #[serde(skip_serializing_if = "Option::is_none")]
8441 pub index: Option<String>,
8443 #[serde(rename = "Name")]
8444 #[serde(skip_serializing_if = "Option::is_none")]
8445 pub name: Option<String>,
8447 #[serde(rename = "Official")]
8448 #[serde(skip_serializing_if = "Option::is_none")]
8449 pub official: Option<String>,
8451 #[serde(rename = "Stars")]
8452 #[serde(skip_serializing_if = "Option::is_none")]
8453 pub stars: Option<i64>,
8455 #[serde(rename = "Tag")]
8456 #[serde(skip_serializing_if = "Option::is_none")]
8457 pub tag: Option<String>,
8459}
8460
8461#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8462pub struct VolumeCreate {
8464 #[serde(rename = "Driver")]
8465 pub driver: String,
8467 #[serde(rename = "DriverOpts")]
8468 #[serde(default)]
8469 #[serde(deserialize_with = "deserialize_nonoptional_map")]
8470 pub driver_opts: HashMap<String, String>,
8473 #[serde(rename = "Labels")]
8474 #[serde(default)]
8475 #[serde(deserialize_with = "deserialize_nonoptional_map")]
8476 pub labels: HashMap<String, String>,
8478 #[serde(rename = "Name")]
8479 pub name: String,
8481}
8482
8483pub type VolumeListLibpod = Vec<VolumeConfigResponse>;
8485
8486pub type VolumePruneLibpod = Vec<PruneReport>;
8488
8489pub type ContainerCreateBodyParam = CreateContainerConfig;
8491
8492pub type ContainerCreateLibpodCreateParam = SpecGenerator;
8495
8496pub type ContainerUpdateLibpodResourcesParam = UpdateEntities;
8498
8499pub type ManifestAddLibpodOptionsParam = ManifestAddOptions;
8501
8502pub type ManifestCreateLibpodOptionsParam = ManifestModifyOptions;
8508
8509pub type ManifestModifyLibpodOptionsParam = ManifestModifyOptions;
8515
8516pub type NetworkCreateLibpodCreateParam = NetworkCreateLibpod;
8518
8519pub type PodCreateLibpodCreateParam = PodSpecGenerator;
8521
8522pub type SecretCreateCreateParam = SecretCreate;
8523
8524pub type SecretInspectCompatResponse = SecretInfoReportCompat;
8525
8526pub type SecretInspectResponse = SecretInfoReport;
8527
8528pub type SystemAuthAuthConfigParam = AuthConfig;
8530
8531pub type VolumeCreateCreateParam = VolumeCreate;
8533
8534pub type VolumeCreateLibpodCreateParam = VolumeCreateOptions;
8536
8537pub type BadParamError = ErrorModel;
8539
8540pub type ConflictError = ErrorModel;
8542
8543pub type ContainerAlreadyStartedError = ErrorModel;
8545
8546pub type ContainerAlreadyStoppedError = ErrorModel;
8548
8549pub type ContainerInspectResponse = ContainerJson;
8551
8552pub type ContainerInspectResponseLibpod = InspectContainerData;
8558
8559pub type ContainerNotFound = ErrorModel;
8561
8562pub type ContainerTopResponse = ContainerTopOkBody;
8564
8565pub type ExecSessionInspect = InspectExecSession;
8566
8567pub type ExecSessionNotFound = ErrorModel;
8569
8570pub type HealthCheck = HealthCheckResults;
8572
8573pub type ImageNotFound = ErrorModel;
8575
8576pub type ImagesImportResponseLibpod = ImageImportReport;
8577
8578pub type ImagesLoadResponseLibpod = ImageLoadReport;
8579
8580pub type ImagesPullResponseLibpod = LibpodImagesPullReport;
8581
8582pub type ImagesRemoveResponseLibpod = LibpodImagesRemoveReport;
8585
8586pub type ImagesScpResponseLibpod = ScpReport;
8587
8588pub type InfoResponse = Info;
8591
8592pub type InspectImageResponseLibpod = ImageData;
8593
8594pub type InternalError = ErrorModel;
8596
8597pub type ManifestInspect = Schema2ListPublic;
8600
8601pub type ManifestNotFound = ErrorModel;
8603
8604pub type NetworkConnectRequest = NetworkConnect;
8606
8607pub type NetworkConnectRequestLibpod = NetworkConnectOptions;
8610
8611pub type NetworkCreateResponse = Network;
8612
8613pub type NetworkDisconnectRequest = NetworkDisconnect;
8615
8616pub type NetworkInspectCompat = NetworkResource;
8618
8619pub type NetworkInspectResponse = Network;
8620
8621pub type NetworkNotFound = ErrorModel;
8623
8624pub type NetworkUpdateRequestLibpod = NetworkUpdateOptions;
8626
8627pub type PlayKubeResponseLibpod = PlayKubeReport;
8628
8629pub type PodAlreadyStartedError = ErrorModel;
8631
8632pub type PodAlreadyStoppedError = ErrorModel;
8634
8635pub type PodInspectResponse = InspectPodData;
8638
8639pub type PodKillResponse = PodKillReport;
8640
8641pub type PodNotFound = ErrorModel;
8643
8644pub type PodPauseResponse = PodPauseReport;
8645
8646pub type PodPruneResponse = PodPruneReport;
8647
8648pub type PodRestartResponse = PodRestartReport;
8649
8650pub type PodRmResponse = PodRmReport;
8651
8652pub type PodStartResponse = PodStartReport;
8653
8654pub type PodStopResponse = PodStopReport;
8655
8656pub type PodTopResponse = PodTopOkBody;
8657
8658pub type PodUnpauseResponse = PodUnpauseReport;
8659
8660pub type SystemAuthResponse = AuthReport;
8662
8663pub type SystemDiskUsage = SystemDfReport;
8665
8666pub type SystemPruneResponse = SystemPruneReport;
8667
8668pub type TreeResponse = ImageTreeReport;
8670
8671pub type VersionResponse = ComponentVersion;
8672
8673pub type VolumeCreateResponse = VolumeConfigResponse;
8674
8675pub type VolumeInspect = Volume;
8677
8678pub type VolumeList = ListResponse;
8680
8681pub type VolumeNotFound = ErrorModel;
8683
8684pub type VolumePruneResponse = VolumesPruneReport;