podman_api_stubs/
models.rs

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)]
57/// AuthConfig contains authorization information for connecting to a Registry
58pub struct AuthConfig {
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub auth: Option<String>,
61    #[serde(skip_serializing_if = "Option::is_none")]
62    /// Email is an optional value associated with the username.
63    /// This field is deprecated and will be removed in a later
64    /// version of docker.
65    pub email: Option<String>,
66    #[serde(skip_serializing_if = "Option::is_none")]
67    /// IdentityToken is used to authenticate the user and get
68    /// an access token for the registry.
69    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    /// RegistryToken is a bearer token to be sent to a registry
74    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)]
82/// AuthReport describes the response for authentication check
83pub 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)]
93/// AuthenticateOKBody authenticate o k body
94pub struct AuthenticateOkBody {
95    #[serde(rename = "IdentityToken")]
96    /// An opaque token used to authenticate a user after a successful login
97    pub identity_token: String,
98    #[serde(rename = "Status")]
99    /// The status of the authentication
100    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    /// AdditionalGIDMappings specified additional GID mappings to include in
108    /// the generated user namespace.
109    pub additional_gid_mappings: Option<Vec<IdMap>>,
110    #[serde(rename = "AdditionalUIDMappings")]
111    #[serde(skip_serializing_if = "Option::is_none")]
112    /// AdditionalUIDMappings specified additional UID mappings to include in
113    /// the generated user namespace.
114    pub additional_uid_mappings: Option<Vec<IdMap>>,
115    #[serde(rename = "GroupFile")]
116    #[serde(skip_serializing_if = "Option::is_none")]
117    /// GroupFile to use if the container uses a volume.
118    pub group_file: Option<String>,
119    #[serde(rename = "InitialSize")]
120    #[serde(skip_serializing_if = "Option::is_none")]
121    /// InitialSize defines the minimum size for the user namespace.
122    /// The created user namespace will have at least this size.
123    pub initial_size: Option<u32>,
124    #[serde(rename = "PasswdFile")]
125    #[serde(skip_serializing_if = "Option::is_none")]
126    /// PasswdFile to use if the container uses a volume.
127    pub passwd_file: Option<String>,
128    #[serde(rename = "Size")]
129    #[serde(skip_serializing_if = "Option::is_none")]
130    /// Size defines the size for the user namespace.  If it is set to a
131    /// value bigger than 0, the user namespace will have exactly this size.
132    /// If it is not set, some heuristics will be used to find its size.
133    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)]
151/// CapacityRange describes the minimum and maximum capacity a volume should be
152/// created with
153pub struct CapacityRange {
154    #[serde(rename = "LimitBytes")]
155    #[serde(skip_serializing_if = "Option::is_none")]
156    /// LimitBytes specifies that a volume must not be bigger than this. The
157    /// value of 0 indicates an unspecified maximum
158    pub limit_bytes: Option<i64>,
159    #[serde(rename = "RequiredBytes")]
160    #[serde(skip_serializing_if = "Option::is_none")]
161    /// RequiredBytes specifies that a volume must be at least this big. The
162    /// value of 0 indicates an unspecified minimum.
163    pub required_bytes: Option<i64>,
164}
165
166pub type CgroupSpec = String;
167
168/// CgroupnsMode represents the cgroup namespace mode of the container
169pub type CgroupnsMode = String;
170
171pub type ClusterOptions = Value;
172
173#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
174/// ClusterVolume contains options and information specific to, and only present
175/// on, Swarm CSI cluster volumes.
176pub 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    /// ID is the Swarm ID of the volume. Because cluster volumes are Swarm
183    /// objects, they have an ID, unlike non-cluster volumes, which only have a
184    /// Name. This ID can be used to refer to the cluster volume.
185    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    /// PublishStatus contains the status of the volume as it pertains to its
191    /// publishing on Nodes.
192    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    /// Group defines the volume group of this volume. Volumes belonging to the
215    /// same group can be referred to by group name when creating Services.
216    /// Referring to a volume by group instructs swarm to treat volumes in that
217    /// group interchangeably for the purpose of scheduling. Volumes with an
218    /// empty string for a group technically all belong to the same, emptystring
219    /// group.
220    pub group: Option<String>,
221    #[serde(rename = "Secrets")]
222    #[serde(skip_serializing_if = "Option::is_none")]
223    /// Secrets defines Swarm Secrets that are passed to the CSI storage plugin
224    /// when operating on this volume.
225    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)]
269/// It should hold only portable information about the container.
270/// Here, "portable" means "independent from the host we are running on".
271/// Non-portable information *should* appear in HostConfig.
272/// All fields added to this struct must be marked `omitempty` to keep getting
273/// predictable hashes from the old `v1Compatibility` configuration.
274pub 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)]
348/// ConfigReference specifies the source which provides a network's configuration
349pub 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
416/// no error
417pub type ContainerArchive200Response = Vec<u8>;
418
419/// no error
420pub type ContainerArchiveLibpod200Response = Vec<u8>;
421
422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
423pub struct ContainerBasicConfig {
424    #[serde(skip_serializing_if = "Option::is_none")]
425    /// Annotations are key-value options passed into the container runtime
426    /// that can be used to trigger special behavior.
427    /// Optional.
428    pub annotations: Option<HashMap<String, String>>,
429    #[serde(skip_serializing_if = "Option::is_none")]
430    /// Command is the container's command.
431    /// If not given and Image is specified, this will be populated by the
432    /// image's configuration.
433    /// Optional.
434    pub command: Option<Vec<String>>,
435    #[serde(skip_serializing_if = "Option::is_none")]
436    /// ConmonPidFile is a path at which a PID file for Conmon will be
437    /// placed.
438    /// If not given, a default location will be used.
439    /// Optional.
440    pub conmon_pid_file: Option<String>,
441    #[serde(rename = "containerCreateCommand")]
442    #[serde(skip_serializing_if = "Option::is_none")]
443    /// ContainerCreateCommand is the command that was used to create this
444    /// container.
445    /// This will be shown in the output of Inspect() on the container, and
446    /// may also be used by some tools that wish to recreate the container
447    /// (e.g. `podman generate systemd --new`).
448    /// Optional.
449    pub container_create_command: Option<Vec<String>>,
450    #[serde(rename = "dependencyContainers")]
451    #[serde(skip_serializing_if = "Option::is_none")]
452    /// DependencyContainers is an array of containers this container
453    /// depends on. Dependency containers must be started before this
454    /// container. Dependencies can be specified by name or full/partial ID.
455    /// Optional.
456    pub dependency_containers: Option<Vec<String>>,
457    #[serde(skip_serializing_if = "Option::is_none")]
458    /// Entrypoint is the container's entrypoint.
459    /// If not given and Image is specified, this will be populated by the
460    /// image's configuration.
461    /// Optional.
462    pub entrypoint: Option<Vec<String>>,
463    #[serde(skip_serializing_if = "Option::is_none")]
464    /// Env is a set of environment variables that will be set in the
465    /// container.
466    /// Optional.
467    pub env: Option<HashMap<String, String>>,
468    #[serde(skip_serializing_if = "Option::is_none")]
469    /// EnvHost indicates that the host environment should be added to container
470    /// Optional.
471    pub env_host: Option<bool>,
472    #[serde(skip_serializing_if = "Option::is_none")]
473    /// EnvMerge takes the specified environment variables from image and preprocess them before injecting them into the
474    /// container.
475    pub envmerge: Option<Vec<String>>,
476    #[serde(skip_serializing_if = "Option::is_none")]
477    /// GroupEntry specifies arbitrary data to append to a file.
478    pub group_entry: Option<String>,
479    #[serde(skip_serializing_if = "Option::is_none")]
480    /// Hostname is the container's hostname. If not set, the hostname will
481    /// not be modified (if UtsNS is not private) or will be set to the
482    /// container ID (if UtsNS is private).
483    /// Conflicts with UtsNS if UtsNS is not set to private.
484    /// Optional.
485    pub hostname: Option<String>,
486    #[serde(skip_serializing_if = "Option::is_none")]
487    /// HostUsers is a list of host usernames or UIDs to add to the container
488    /// etc/passwd file
489    pub hostusers: Option<Vec<String>>,
490    #[serde(skip_serializing_if = "Option::is_none")]
491    /// EnvHTTPProxy indicates that the http host proxy environment variables
492    /// should be added to container
493    /// Optional.
494    pub httpproxy: Option<bool>,
495    #[serde(skip_serializing_if = "Option::is_none")]
496    /// ImageArch is the user-specified image architecture
497    pub image_arch: Option<String>,
498    #[serde(skip_serializing_if = "Option::is_none")]
499    /// ImageOS is the user-specified image OS
500    pub image_os: Option<String>,
501    #[serde(skip_serializing_if = "Option::is_none")]
502    /// ImageVariant is the user-specified image variant
503    pub image_variant: Option<String>,
504    #[serde(skip_serializing_if = "Option::is_none")]
505    /// InitContainerType describes if this container is an init container
506    /// and if so, what type: always or once
507    pub init_container_type: Option<String>,
508    #[serde(skip_serializing_if = "Option::is_none")]
509    /// Labels are key-value pairs that are used to add metadata to
510    /// containers.
511    /// Optional.
512    pub labels: Option<HashMap<String, String>>,
513    pub log_configuration: Option<LogConfigLibpod>,
514    #[serde(skip_serializing_if = "Option::is_none")]
515    /// Passwd is a container run option that determines if we are validating users/groups before running the container
516    pub manage_password: Option<bool>,
517    #[serde(skip_serializing_if = "Option::is_none")]
518    /// Name is the name the container will be given.
519    /// If no name is provided, one will be randomly generated.
520    /// Optional.
521    pub name: Option<String>,
522    #[serde(skip_serializing_if = "Option::is_none")]
523    /// Namespace is the libpod namespace the container will be placed in.
524    /// Optional.
525    pub namespace: Option<String>,
526    #[serde(skip_serializing_if = "Option::is_none")]
527    /// OCIRuntime is the name of the OCI runtime that will be used to create
528    /// the container.
529    /// If not specified, the default will be used.
530    /// Optional.
531    pub oci_runtime: Option<String>,
532    #[serde(skip_serializing_if = "Option::is_none")]
533    /// PasswdEntry specifies arbitrary data to append to a file.
534    pub passwd_entry: Option<String>,
535    pub personality: Option<LinuxPersonality>,
536    pub pidns: Option<Namespace>,
537    #[serde(skip_serializing_if = "Option::is_none")]
538    /// Pod is the ID of the pod the container will join.
539    /// Optional.
540    pub pod: Option<String>,
541    #[serde(skip_serializing_if = "Option::is_none")]
542    /// RawImageName is the user-specified and unprocessed input referring
543    /// to a local or a remote image.
544    pub raw_image_name: Option<String>,
545    #[serde(skip_serializing_if = "Option::is_none")]
546    /// Remove indicates if the container should be removed once it has been started
547    /// and exits
548    pub remove: Option<bool>,
549    #[serde(skip_serializing_if = "Option::is_none")]
550    /// RestartPolicy is the container's restart policy - an action which
551    /// will be taken when the container exits.
552    /// If not given, the default policy, which does nothing, will be used.
553    /// Optional.
554    pub restart_policy: Option<String>,
555    #[serde(skip_serializing_if = "Option::is_none")]
556    /// RestartRetries is the number of attempts that will be made to restart
557    /// the container.
558    /// Only available when RestartPolicy is set to "on-failure".
559    /// Optional.
560    pub restart_tries: Option<u64>,
561    #[serde(rename = "sdnotifyMode")]
562    #[serde(skip_serializing_if = "Option::is_none")]
563    /// Determine how to handle the NOTIFY_SOCKET - do we participate or pass it through
564    /// "container" - let the OCI runtime deal with it, advertise conmon's MAINPID
565    /// "conmon-only" - advertise conmon's MAINPID, send READY when started, don't pass to OCI
566    /// "ignore" - unset NOTIFY_SOCKET
567    pub sdnotify_mode: Option<String>,
568    #[serde(skip_serializing_if = "Option::is_none")]
569    /// EnvSecrets are secrets that will be set as environment variables
570    /// Optional.
571    pub secret_env: Option<HashMap<String, String>>,
572    #[serde(skip_serializing_if = "Option::is_none")]
573    /// Stdin is whether the container will keep its STDIN open.
574    pub stdin: Option<bool>,
575    pub stop_signal: Option<i64>,
576    #[serde(skip_serializing_if = "Option::is_none")]
577    /// StopTimeout is a timeout between the container's stop signal being
578    /// sent and SIGKILL being sent.
579    /// If not provided, the default will be used.
580    /// If 0 is used, stop signal will not be sent, and SIGKILL will be sent
581    /// instead.
582    /// Optional.
583    pub stop_timeout: Option<u64>,
584    #[serde(skip_serializing_if = "Option::is_none")]
585    /// Sysctl sets kernel parameters for the container
586    pub sysctl: Option<HashMap<String, String>>,
587    #[serde(skip_serializing_if = "Option::is_none")]
588    /// Systemd is whether the container will be started in systemd mode.
589    /// Valid options are "true", "false", and "always".
590    /// "true" enables this mode only if the binary run in the container is
591    /// sbin/init or systemd. "always" unconditionally enables systemd mode.
592    /// "false" unconditionally disables systemd mode.
593    /// If enabled, mounts and stop signal will be modified.
594    /// If set to "always" or set to "true" and conditionally triggered,
595    /// conflicts with StopSignal.
596    /// If not specified, "false" will be assumed.
597    /// Optional.
598    pub systemd: Option<String>,
599    #[serde(skip_serializing_if = "Option::is_none")]
600    /// Terminal is whether the container will create a PTY.
601    /// Optional.
602    pub terminal: Option<bool>,
603    #[serde(skip_serializing_if = "Option::is_none")]
604    /// Timeout is a maximum time in seconds the container will run before
605    /// main process is sent SIGKILL.
606    /// If 0 is used, signal will not be sent. Container can run indefinitely
607    /// Optional.
608    pub timeout: Option<u64>,
609    #[serde(skip_serializing_if = "Option::is_none")]
610    /// Timezone is the timezone inside the container.
611    /// Local means it has the same timezone as the host machine
612    /// Optional.
613    pub timezone: Option<String>,
614    #[serde(skip_serializing_if = "Option::is_none")]
615    /// UnsetEnv unsets the specified default environment variables from the image or from buildin or containers.conf
616    /// Optional.
617    pub unsetenv: Option<Vec<String>>,
618    #[serde(skip_serializing_if = "Option::is_none")]
619    /// UnsetEnvAll unsetall default environment variables from the image or from buildin or containers.conf
620    /// UnsetEnvAll unsets all default environment variables from the image or from buildin
621    /// Optional.
622    pub unsetenvall: Option<bool>,
623    pub utsns: Option<Namespace>,
624}
625
626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
627/// ContainerCgroupConfig contains configuration information about a container's
628/// cgroups.
629pub struct ContainerCgroupConfig {
630    #[serde(skip_serializing_if = "Option::is_none")]
631    /// CgroupParent is the container's Cgroup parent.
632    /// If not set, the default for the current cgroup driver will be used.
633    /// Optional.
634    pub cgroup_parent: Option<String>,
635    pub cgroupns: Option<Namespace>,
636    #[serde(skip_serializing_if = "Option::is_none")]
637    /// CgroupsMode sets a policy for how cgroups will be created in the
638    /// container, including the ability to disable creation entirely.
639    pub cgroups_mode: Option<String>,
640}
641
642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
643/// ContainerChangeResponseItem change item in response to ContainerChanges operation
644pub struct ContainerChangeResponseItem {
645    #[serde(rename = "Kind")]
646    /// Kind of change
647    pub kind: u8,
648    #[serde(rename = "Path")]
649    /// Path to file that has changed
650    pub path: String,
651}
652
653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
654/// ContainerCreateResponse is the response struct for creating a container
655pub struct ContainerCreateResponse {
656    #[serde(rename = "Id")]
657    /// ID of the container created
658    pub id: String,
659    #[serde(rename = "Warnings")]
660    #[serde(default)]
661    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
662    /// Warnings during container creation
663    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    /// Attach to stderr of the exec command
671    pub attach_stderr: Option<bool>,
672    #[serde(rename = "AttachStdin")]
673    #[serde(skip_serializing_if = "Option::is_none")]
674    /// Attach to stdin of the exec command
675    pub attach_stdin: Option<bool>,
676    #[serde(rename = "AttachStdout")]
677    #[serde(skip_serializing_if = "Option::is_none")]
678    /// Attach to stdout of the exec command
679    pub attach_stdout: Option<bool>,
680    #[serde(rename = "Cmd")]
681    #[serde(skip_serializing_if = "Option::is_none")]
682    /// Command to run, as a string or array of strings.
683    pub cmd: Option<Vec<String>>,
684    #[serde(rename = "DetachKeys")]
685    #[serde(skip_serializing_if = "Option::is_none")]
686    /// "Override the key sequence for detaching a container. Format is a single character [a-Z] or ctrl-<value> where <value> is one of: a-z, @, ^, [, , or _."
687    pub detach_keys: Option<String>,
688    #[serde(rename = "Env")]
689    #[serde(skip_serializing_if = "Option::is_none")]
690    /// A list of environment variables in the form ["VAR=value", ...]
691    pub env: Option<Vec<String>>,
692    #[serde(rename = "Privileged")]
693    #[serde(skip_serializing_if = "Option::is_none")]
694    /// Runs the exec process with extended privileges
695    pub privileged: Option<bool>,
696    #[serde(rename = "Tty")]
697    #[serde(skip_serializing_if = "Option::is_none")]
698    /// Allocate a pseudo-TTY
699    pub tty: Option<bool>,
700    #[serde(rename = "User")]
701    #[serde(skip_serializing_if = "Option::is_none")]
702    /// "The user, and optionally, group to run the exec process inside the container. Format is one of: user, user:group, uid, or uid:gid."
703    pub user: Option<String>,
704    #[serde(rename = "WorkingDir")]
705    #[serde(skip_serializing_if = "Option::is_none")]
706    /// The working directory for the exec process inside the container.
707    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    /// Attach to stderr of the exec command
715    pub attach_stderr: Option<bool>,
716    #[serde(rename = "AttachStdin")]
717    #[serde(skip_serializing_if = "Option::is_none")]
718    /// Attach to stdin of the exec command
719    pub attach_stdin: Option<bool>,
720    #[serde(rename = "AttachStdout")]
721    #[serde(skip_serializing_if = "Option::is_none")]
722    /// Attach to stdout of the exec command
723    pub attach_stdout: Option<bool>,
724    #[serde(rename = "Cmd")]
725    #[serde(skip_serializing_if = "Option::is_none")]
726    /// Command to run, as a string or array of strings.
727    pub cmd: Option<Vec<String>>,
728    #[serde(rename = "DetachKeys")]
729    #[serde(skip_serializing_if = "Option::is_none")]
730    /// "Override the key sequence for detaching a container. Format is a single character [a-Z] or ctrl-<value> where <value> is one of: a-z, @, ^, [, , or _."
731    pub detach_keys: Option<String>,
732    #[serde(rename = "Env")]
733    #[serde(skip_serializing_if = "Option::is_none")]
734    /// A list of environment variables in the form ["VAR=value", ...]
735    pub env: Option<Vec<String>>,
736    #[serde(rename = "Privileged")]
737    #[serde(skip_serializing_if = "Option::is_none")]
738    /// Runs the exec process with extended privileges
739    pub privileged: Option<bool>,
740    #[serde(rename = "Tty")]
741    #[serde(skip_serializing_if = "Option::is_none")]
742    /// Allocate a pseudo-TTY
743    pub tty: Option<bool>,
744    #[serde(rename = "User")]
745    #[serde(skip_serializing_if = "Option::is_none")]
746    /// "The user, and optionally, group to run the exec process inside the container. Format is one of: user, user:group, uid, or uid:gid."
747    pub user: Option<String>,
748    #[serde(rename = "WorkingDir")]
749    #[serde(skip_serializing_if = "Option::is_none")]
750    /// The working directory for the exec process inside the container.
751    pub working_dir: Option<String>,
752}
753
754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
755/// ContainerHealthCheckConfig describes a container healthcheck with attributes
756/// like command, retries, interval, start period, and timeout.
757pub 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)]
765/// ContainerJSON is newly used struct along with MountPoint
766pub 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
841/// mounted container
842pub type ContainerMountLibpod200Response = String;
843
844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
845/// ContainerNetworkConfig contains information on a container's network
846/// configuration.
847pub struct ContainerNetworkConfig {
848    #[serde(rename = "Networks")]
849    #[serde(skip_serializing_if = "Option::is_none")]
850    /// Map of networks names or ids that the container should join.
851    /// You can request additional settings for each network, you can
852    /// set network aliases, static ips, static mac address  and the
853    /// network interface name for this container on the specific network.
854    /// If the map is empty and the bridge network mode is set the container
855    /// will be joined to the default network.
856    pub networks: Option<HashMap<String, PerNetworkOptions>>,
857    #[serde(skip_serializing_if = "Option::is_none")]
858    /// CNINetworks is a list of CNI networks to join the container to.
859    /// If this list is empty, the default CNI network will be joined
860    /// instead. If at least one entry is present, we will not join the
861    /// default network (unless it is part of this list).
862    /// Only available if NetNS is set to bridge.
863    /// Optional.
864    /// Deprecated: as of podman 4.0 use "Networks" instead.
865    pub cni_networks: Option<Vec<String>>,
866    #[serde(skip_serializing_if = "Option::is_none")]
867    /// DNSOptions is a set of DNS options that will be used in the
868    /// container's resolv.conf, replacing the host's DNS options which are
869    /// used by default.
870    /// Conflicts with UseImageResolvConf.
871    /// Optional.
872    pub dns_option: Option<Vec<String>>,
873    #[serde(skip_serializing_if = "Option::is_none")]
874    /// DNSSearch is a set of DNS search domains that will be used in the
875    /// container's resolv.conf, replacing the host's DNS search domains
876    /// which are used by default.
877    /// Conflicts with UseImageResolvConf.
878    /// Optional.
879    pub dns_search: Option<Vec<String>>,
880    #[serde(skip_serializing_if = "Option::is_none")]
881    /// DNSServers is a set of DNS servers that will be used in the
882    /// container's resolv.conf, replacing the host's DNS Servers which are
883    /// used by default.
884    /// Conflicts with UseImageResolvConf.
885    /// Optional.
886    pub dns_server: Option<Vec<String>>,
887    #[serde(skip_serializing_if = "Option::is_none")]
888    /// Expose is a number of ports that will be forwarded to the container
889    /// if PublishExposedPorts is set.
890    /// Expose is a map of uint16 (port number) to a string representing
891    /// protocol i.e map[uint16]string. Allowed protocols are "tcp", "udp", and "sctp", or some
892    /// combination of the three separated by commas.
893    /// If protocol is set to "" we will assume TCP.
894    /// Only available if NetNS is set to Bridge or Slirp, and
895    /// PublishExposedPorts is set.
896    /// Optional.
897    pub expose: Option<Value>,
898    #[serde(skip_serializing_if = "Option::is_none")]
899    /// HostAdd is a set of hosts which will be added to the container's
900    /// etc/hosts file.
901    /// Conflicts with UseImageHosts.
902    /// Optional.
903    pub hostadd: Option<Vec<String>>,
904    pub netns: Option<Namespace>,
905    #[serde(skip_serializing_if = "Option::is_none")]
906    /// NetworkOptions are additional options for each network
907    /// Optional.
908    pub network_options: Option<HashMap<String, Vec<String>>>,
909    #[serde(skip_serializing_if = "Option::is_none")]
910    /// PortBindings is a set of ports to map into the container.
911    /// Only available if NetNS is set to bridge, slirp, or pasta.
912    /// Optional.
913    pub portmappings: Option<Vec<PortMapping>>,
914    #[serde(skip_serializing_if = "Option::is_none")]
915    /// PublishExposedPorts will publish ports specified in the image to
916    /// random unused ports (guaranteed to be above 1024) on the host.
917    /// This is based on ports set in Expose below, and any ports specified
918    /// by the Image (if one is given).
919    /// Only available if NetNS is set to Bridge or Slirp.
920    pub publish_image_ports: Option<bool>,
921    #[serde(skip_serializing_if = "Option::is_none")]
922    /// UseImageHosts indicates that /etc/hosts should not be managed by
923    /// Podman, and instead sourced from the image.
924    /// Conflicts with HostAdd.
925    /// Do not set omitempty here, if this is false it should be set to not get
926    /// the server default.
927    /// Ideally this would be a pointer so we could differentiate between an
928    /// explicitly false/true and unset (containers.conf default). However
929    /// specgen is stable so we can not change this right now.
930    /// TODO (5.0): change to pointer
931    pub use_image_hosts: Option<bool>,
932    #[serde(skip_serializing_if = "Option::is_none")]
933    /// UseImageResolvConf indicates that resolv.conf should not be managed
934    /// by Podman, but instead sourced from the image.
935    /// Conflicts with DNSServer, DNSSearch, DNSOption.
936    pub use_image_resolve_conf: Option<bool>,
937}
938
939#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
940/// ContainerNode stores information about the node that a container
941/// is running on.  It's only used by the Docker Swarm standalone API
942pub 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    /// CPU period of the cpuset, determined by --cpus
970    pub cpu_period: Option<u64>,
971    #[serde(skip_serializing_if = "Option::is_none")]
972    /// CPU quota of the cpuset, determined by --cpus
973    pub cpu_quota: Option<i64>,
974    #[serde(skip_serializing_if = "Option::is_none")]
975    /// OOMScoreAdj adjusts the score used by the OOM killer to determine
976    /// processes to kill for the container's process.
977    /// Optional.
978    pub oom_score_adj: Option<i64>,
979    #[serde(skip_serializing_if = "Option::is_none")]
980    /// Rlimits are POSIX rlimits to apply to the container.
981    /// Optional.
982    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    /// IO read rate limit per cgroup per device, bytes per second
987    pub throttle_read_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
988    #[serde(rename = "throttleReadIOPSDevice")]
989    #[serde(skip_serializing_if = "Option::is_none")]
990    /// IO read rate limit per cgroup per device, IO per second
991    pub throttle_read_iops_device: Option<HashMap<String, LinuxThrottleDevice>>,
992    #[serde(rename = "throttleWriteBpsDevice")]
993    #[serde(skip_serializing_if = "Option::is_none")]
994    /// IO write rate limit per cgroup per device, bytes per second
995    pub throttle_write_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
996    #[serde(rename = "throttleWriteIOPSDevice")]
997    #[serde(skip_serializing_if = "Option::is_none")]
998    /// IO write rate limit per cgroup per device, IO per second
999    pub throttle_write_iops_device: Option<HashMap<String, LinuxThrottleDevice>>,
1000    #[serde(skip_serializing_if = "Option::is_none")]
1001    /// CgroupConf are key-value options passed into the container runtime
1002    /// that are used to configure cgroup v2.
1003    /// Optional.
1004    pub unified: Option<HashMap<String, String>>,
1005    #[serde(rename = "weightDevice")]
1006    #[serde(skip_serializing_if = "Option::is_none")]
1007    /// Weight per cgroup per device, can override BlkioWeight
1008    pub weight_device: Option<HashMap<String, LinuxWeightDevice>>,
1009}
1010
1011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1012/// ContainerSecurityConfig is a container's security features, including
1013/// SELinux, Apparmor, and Seccomp.
1014pub struct ContainerSecurityConfig {
1015    #[serde(skip_serializing_if = "Option::is_none")]
1016    /// ApparmorProfile is the name of the Apparmor profile the container
1017    /// will use.
1018    /// Optional.
1019    pub apparmor_profile: Option<String>,
1020    #[serde(skip_serializing_if = "Option::is_none")]
1021    /// CapAdd are capabilities which will be added to the container.
1022    /// Conflicts with Privileged.
1023    /// Optional.
1024    pub cap_add: Option<Vec<String>>,
1025    #[serde(skip_serializing_if = "Option::is_none")]
1026    /// CapDrop are capabilities which will be removed from the container.
1027    /// Conflicts with Privileged.
1028    /// Optional.
1029    pub cap_drop: Option<Vec<String>>,
1030    #[serde(skip_serializing_if = "Option::is_none")]
1031    /// Groups are a list of supplemental groups the container's user will
1032    /// be granted access to.
1033    /// Optional.
1034    pub groups: Option<Vec<String>>,
1035    pub idmappings: Option<IdMappingOptions>,
1036    #[serde(skip_serializing_if = "Option::is_none")]
1037    /// LabelNested indicates whether or not the container is allowed to
1038    /// run fully nested containers including labelling
1039    pub label_nested: Option<bool>,
1040    #[serde(skip_serializing_if = "Option::is_none")]
1041    /// Mask is the path we want to mask in the container. This masks the paths
1042    /// given in addition to the default list.
1043    /// Optional
1044    pub mask: Option<Vec<String>>,
1045    #[serde(skip_serializing_if = "Option::is_none")]
1046    /// NoNewPrivileges is whether the container will set the no new
1047    /// privileges flag on create, which disables gaining additional
1048    /// privileges (e.g. via setuid) in the container.
1049    pub no_new_privileges: Option<bool>,
1050    #[serde(skip_serializing_if = "Option::is_none")]
1051    /// Privileged is whether the container is privileged.
1052    /// Privileged does the following:
1053    /// Adds all devices on the system to the container.
1054    /// Adds all capabilities to the container.
1055    /// Disables Seccomp, SELinux, and Apparmor confinement.
1056    /// (Though SELinux can be manually re-enabled).
1057    /// TODO: this conflicts with things.
1058    /// TODO: this does more.
1059    pub privileged: Option<bool>,
1060    #[serde(skip_serializing_if = "Option::is_none")]
1061    /// ProcOpts are the options used for the proc mount.
1062    pub procfs_opts: Option<Vec<String>>,
1063    #[serde(skip_serializing_if = "Option::is_none")]
1064    /// ReadOnlyFilesystem indicates that everything will be mounted
1065    /// as read-only
1066    pub read_only_filesystem: Option<bool>,
1067    #[serde(skip_serializing_if = "Option::is_none")]
1068    /// ReadWriteTmpfs indicates that when running with a ReadOnlyFilesystem
1069    /// mount temporary file systems
1070    pub read_write_tmpfs: Option<bool>,
1071    #[serde(skip_serializing_if = "Option::is_none")]
1072    /// SeccompPolicy determines which seccomp profile gets applied
1073    /// the container. valid values: empty,default,image
1074    pub seccomp_policy: Option<String>,
1075    #[serde(skip_serializing_if = "Option::is_none")]
1076    /// SeccompProfilePath is the path to a JSON file containing the
1077    /// container's Seccomp profile.
1078    /// If not specified, no Seccomp profile will be used.
1079    /// Optional.
1080    pub seccomp_profile_path: Option<String>,
1081    #[serde(skip_serializing_if = "Option::is_none")]
1082    /// SelinuxProcessLabel is the process label the container will use.
1083    /// If SELinux is enabled and this is not specified, a label will be
1084    /// automatically generated if not specified.
1085    /// Optional.
1086    pub selinux_opts: Option<Vec<String>>,
1087    #[serde(skip_serializing_if = "Option::is_none")]
1088    /// Umask is the umask the init process of the container will be run with.
1089    pub umask: Option<String>,
1090    #[serde(skip_serializing_if = "Option::is_none")]
1091    /// Unmask is the path we want to unmask in the container. To override
1092    /// all the default paths that are masked, set unmask=ALL.
1093    pub unmask: Option<Vec<String>>,
1094    #[serde(skip_serializing_if = "Option::is_none")]
1095    /// User is the user the container will be run as.
1096    /// Can be given as a UID or a username; if a username, it will be
1097    /// resolved within the container, using the container's /etc/passwd.
1098    /// If unset, the container will be run as root.
1099    /// Optional.
1100    pub user: Option<String>,
1101    pub userns: Option<Namespace>,
1102}
1103
1104/// mounted containers
1105pub type ContainerShowMountedLibpod200Response = HashMap<String, String>;
1106
1107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1108/// ContainerSize holds the size of the container's root filesystem and top
1109/// read-write layer.
1110pub 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)]
1120/// ContainerState stores container's running state
1121/// it's part of ContainerJSONBase and will return by "inspect" command
1122pub 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)]
1161/// ContainerStats contains the statistics information for a running container
1162pub 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
1218/// no error
1219pub type ContainerStats200Response = Value;
1220
1221#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1222/// ContainerStorageConfig contains information on the storage configuration of a
1223/// container.
1224pub struct ContainerStorageConfig {
1225    #[serde(skip_serializing_if = "Option::is_none")]
1226    /// ChrootDirs is an additional set of directories that need to be
1227    /// treated as root directories. Standard bind mounts will be mounted
1228    /// into paths relative to these directories.
1229    pub chroot_directories: Option<Vec<String>>,
1230    #[serde(skip_serializing_if = "Option::is_none")]
1231    /// Create the working directory if it doesn't exist.
1232    /// If unset, it doesn't create it.
1233    /// Optional.
1234    pub create_working_dir: Option<bool>,
1235    #[serde(skip_serializing_if = "Option::is_none")]
1236    /// DeviceCgroupRule are device cgroup rules that allow containers
1237    /// to use additional types of devices.
1238    pub device_cgroup_rule: Option<Vec<LinuxDeviceCgroup>>,
1239    #[serde(skip_serializing_if = "Option::is_none")]
1240    /// Devices are devices that will be added to the container.
1241    /// Optional.
1242    pub devices: Option<Vec<LinuxDevice>>,
1243    #[serde(skip_serializing_if = "Option::is_none")]
1244    /// DevicesFrom is a way to ensure your container inherits device specific information from another container
1245    pub devices_from: Option<Vec<String>>,
1246    #[serde(skip_serializing_if = "Option::is_none")]
1247    /// HostDeviceList is used to recreate the mounted device on inherited containers
1248    pub host_device_list: Option<Vec<LinuxDevice>>,
1249    #[serde(skip_serializing_if = "Option::is_none")]
1250    /// Image is the image the container will be based on. The image will be
1251    /// used as the container's root filesystem, and its environment vars,
1252    /// volumes, and other configuration will be applied to the container.
1253    /// Conflicts with Rootfs.
1254    /// At least one of Image or Rootfs must be specified.
1255    pub image: Option<String>,
1256    #[serde(skip_serializing_if = "Option::is_none")]
1257    /// ImageVolumeMode indicates how image volumes will be created.
1258    /// Supported modes are "ignore" (do not create), "tmpfs" (create as
1259    /// tmpfs), and "anonymous" (create as anonymous volumes).
1260    /// The default if unset is anonymous.
1261    /// Optional.
1262    pub image_volume_mode: Option<String>,
1263    #[serde(skip_serializing_if = "Option::is_none")]
1264    /// Image volumes bind-mount a container-image mount into the container.
1265    /// Optional.
1266    pub image_volumes: Option<Vec<ImageVolume>>,
1267    #[serde(skip_serializing_if = "Option::is_none")]
1268    /// Init specifies that an init binary will be mounted into the
1269    /// container, and will be used as PID1.
1270    pub init: Option<bool>,
1271    #[serde(skip_serializing_if = "Option::is_none")]
1272    /// InitPath specifies the path to the init binary that will be added if
1273    /// Init is specified above. If not specified, the default set in the
1274    /// Libpod config will be used. Ignored if Init above is not set.
1275    /// Optional.
1276    pub init_path: Option<String>,
1277    pub ipcns: Option<Namespace>,
1278    #[serde(skip_serializing_if = "Option::is_none")]
1279    /// Mounts are mounts that will be added to the container.
1280    /// These will supersede Image Volumes and VolumesFrom volumes where
1281    /// there are conflicts.
1282    /// Optional.
1283    pub mounts: Option<Vec<Mount>>,
1284    #[serde(skip_serializing_if = "Option::is_none")]
1285    /// Overlay volumes are named volumes that will be added to the container.
1286    /// Optional.
1287    pub overlay_volumes: Option<Vec<OverlayVolume>>,
1288    #[serde(skip_serializing_if = "Option::is_none")]
1289    /// Rootfs is the path to a directory that will be used as the
1290    /// container's root filesystem. No modification will be made to the
1291    /// directory, it will be directly mounted into the container as root.
1292    /// Conflicts with Image.
1293    /// At least one of Image or Rootfs must be specified.
1294    pub rootfs: Option<String>,
1295    #[serde(skip_serializing_if = "Option::is_none")]
1296    /// RootfsMapping specifies if there are mappings to apply to the rootfs.
1297    pub rootfs_mapping: Option<String>,
1298    #[serde(skip_serializing_if = "Option::is_none")]
1299    /// RootfsOverlay tells if rootfs is actually an overlay on top of base path
1300    pub rootfs_overlay: Option<bool>,
1301    #[serde(skip_serializing_if = "Option::is_none")]
1302    /// RootfsPropagation is the rootfs propagation mode for the container.
1303    /// If not set, the default of rslave will be used.
1304    /// Optional.
1305    pub rootfs_propagation: Option<String>,
1306    #[serde(skip_serializing_if = "Option::is_none")]
1307    /// Secrets are the secrets that will be added to the container
1308    /// Optional.
1309    pub secrets: Option<Vec<Secret>>,
1310    #[serde(skip_serializing_if = "Option::is_none")]
1311    /// ShmSize is the size of the tmpfs to mount in at /dev/shm, in bytes.
1312    /// Conflicts with ShmSize if IpcNS is not private.
1313    /// Optional.
1314    pub shm_size: Option<i64>,
1315    #[serde(skip_serializing_if = "Option::is_none")]
1316    /// ShmSizeSystemd is the size of systemd-specific tmpfs mounts
1317    /// specifically /run, /run/lock, /var/log/journal and /tmp.
1318    /// Optional
1319    pub shm_size_systemd: Option<i64>,
1320    #[serde(skip_serializing_if = "Option::is_none")]
1321    /// StorageOpts is the container's storage options
1322    /// Optional.
1323    pub storage_opts: Option<HashMap<String, String>>,
1324    #[serde(skip_serializing_if = "Option::is_none")]
1325    /// Volatile specifies whether the container storage can be optimized
1326    /// at the cost of not syncing all the dirty files in memory.
1327    pub volatile: Option<bool>,
1328    #[serde(skip_serializing_if = "Option::is_none")]
1329    /// Volumes are named volumes that will be added to the container.
1330    /// These will supersede Image Volumes and VolumesFrom volumes where
1331    /// there are conflicts.
1332    /// Optional.
1333    pub volumes: Option<Vec<NamedVolume>>,
1334    #[serde(skip_serializing_if = "Option::is_none")]
1335    /// VolumesFrom is a set of containers whose volumes will be added to
1336    /// this container. The name or ID of the container must be provided, and
1337    /// may optionally be followed by a : and then one or more
1338    /// comma-separated options. Valid options are 'ro', 'rw', and 'z'.
1339    /// Options will be used for all volumes sourced from the container.
1340    pub volumes_from: Option<Vec<String>>,
1341    #[serde(skip_serializing_if = "Option::is_none")]
1342    /// WorkDir is the container's working directory.
1343    /// If unset, the default, /, will be used.
1344    /// Optional.
1345    pub work_dir: Option<String>,
1346}
1347
1348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1349/// ContainerTopOKBody OK response to ContainerTop operation
1350pub struct ContainerTopOkBody {
1351    #[serde(rename = "Processes")]
1352    #[serde(default)]
1353    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1354    /// Each process running in the container, where each is process
1355    /// is an array of values corresponding to the titles.
1356    pub processes: Vec<Vec<String>>,
1357    #[serde(rename = "Titles")]
1358    #[serde(default)]
1359    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1360    /// The ps column titles
1361    pub titles: Vec<String>,
1362}
1363
1364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1365/// ContainerUpdateOKBody OK response to ContainerUpdate operation
1366pub struct ContainerUpdateOkBody {
1367    #[serde(rename = "Warnings")]
1368    #[serde(default)]
1369    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1370    /// warnings
1371    pub warnings: Vec<String>,
1372}
1373
1374/// Status code
1375pub 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    /// Error which occurred during prune operation (if any).
1392    /// This field is optional and may be omitted if no error occurred.
1393    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)]
1403/// CreateContainerConfig used when compatible endpoint creates a container
1404pub 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)]
1494/// Volume configuration
1495pub 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    /// Name of the volume driver to use.
1501    pub driver: Option<String>,
1502    #[serde(rename = "DriverOpts")]
1503    #[serde(skip_serializing_if = "Option::is_none")]
1504    /// A mapping of driver options and values. These options are
1505    /// passed directly to the driver and are driver specific.
1506    pub driver_opts: Option<HashMap<String, String>>,
1507    #[serde(rename = "Labels")]
1508    #[serde(skip_serializing_if = "Option::is_none")]
1509    /// User-defined key/value metadata.
1510    pub labels: Option<HashMap<String, String>>,
1511    #[serde(rename = "Name")]
1512    #[serde(skip_serializing_if = "Option::is_none")]
1513    /// The new volume's name. If not specified, Docker generates a name.
1514    pub name: Option<String>,
1515}
1516
1517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1518/// OK response to ContainerCreate operation
1519pub struct CreateResponse {
1520    #[serde(rename = "Id")]
1521    /// The ID of the created container
1522    pub id: String,
1523    #[serde(rename = "Warnings")]
1524    #[serde(default)]
1525    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1526    /// Warnings encountered when creating the container
1527    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)]
1544/// Used by GPU device drivers.
1545pub 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
1563/// The following is an example of the contents of Digest types:
1564///
1565/// sha256:7173b809ca12ec5dee4506cd86be934c4596dd234ee82c0662eac04a8c2c71dc
1566///
1567/// This allows to abstract the digest behind this type and work only in those
1568/// terms.
1569pub 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)]
1582/// DriverData handles the data for a storage driver
1583pub 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
1592/// A Duration represents the elapsed time between two instants
1593/// as an int64 nanosecond count. The representation limits the
1594/// largest representable duration to approximately 290 years.
1595pub type Duration = i64;
1596
1597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1598/// EndpointIPAMConfig represents IPAM configurations for the endpoint
1599pub 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)]
1612/// EndpointResource contains network resources allocated and used for a container in a network
1613pub 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)]
1632/// EndpointSettings stores the network endpoint details
1633pub 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    /// Operational data
1672    pub network_id: Option<String>,
1673}
1674
1675#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1676/// ErrorModel is used in remote connections with podman
1677pub struct ErrorModel {
1678    #[serde(skip_serializing_if = "Option::is_none")]
1679    /// API root cause formatted for automated parsing
1680    pub cause: Option<String>,
1681    #[serde(skip_serializing_if = "Option::is_none")]
1682    /// human error message, formatted for a human to read
1683    pub message: Option<String>,
1684    #[serde(skip_serializing_if = "Option::is_none")]
1685    /// HTTP response code
1686    pub response: Option<i64>,
1687}
1688
1689#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1690pub struct ErrorResponse {
1691    /// The error message.
1692    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    /// Detach from the command. Not presently supported.
1700    pub detach: Option<bool>,
1701    #[serde(rename = "Tty")]
1702    #[serde(skip_serializing_if = "Option::is_none")]
1703    /// Allocate a pseudo-TTY. Presently ignored.
1704    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    /// Detach from the command.
1712    pub detach: Option<bool>,
1713    #[serde(rename = "Tty")]
1714    #[serde(skip_serializing_if = "Option::is_none")]
1715    /// Allocate a pseudo-TTY.
1716    pub tty: Option<bool>,
1717    #[serde(skip_serializing_if = "Option::is_none")]
1718    /// Height of the TTY session in characters. Tty must be set to true to use it.
1719    pub h: Option<isize>,
1720    #[serde(skip_serializing_if = "Option::is_none")]
1721    /// Width of the TTY session in characters. Tty must be set to true to use it.
1722    pub w: Option<isize>,
1723}
1724
1725/// The bits have the same definition on all systems, so that
1726/// information about files can be moved from one system
1727/// to another portably. Not all bits apply to all systems.
1728/// The only required bit is ModeDir for directories.
1729pub type FileMode = u32;
1730
1731/// Kubernetes YAML file describing pod
1732pub type GenerateKubeLibpod200Response = Vec<u8>;
1733
1734/// no error
1735pub type GenerateSystemdLibpod200Response = HashMap<String, String>;
1736
1737#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1738/// GraphDriverData Information about the storage driver used to store the container's and
1739/// image's filesystem.
1740pub struct GraphDriverData {
1741    #[serde(rename = "Data")]
1742    #[serde(default)]
1743    #[serde(deserialize_with = "deserialize_nonoptional_map")]
1744    /// Low-level storage metadata, provided as key/value pairs.
1745    ///
1746    /// This information is driver-specific, and depends on the storage-driver
1747    /// in use, and should be used for informational purposes only.
1748    pub data: HashMap<String, String>,
1749    #[serde(rename = "Name")]
1750    /// Name of the storage driver.
1751    pub name: String,
1752}
1753
1754pub type HardwareAddr = Vec<u8>;
1755
1756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1757/// Health stores information about the container's healthcheck results
1758pub 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)]
1771/// HealthCheckLog describes the results of a single healthcheck
1772pub struct HealthCheckLog {
1773    #[serde(rename = "End")]
1774    #[serde(skip_serializing_if = "Option::is_none")]
1775    /// End time as a string
1776    pub end: Option<String>,
1777    #[serde(rename = "ExitCode")]
1778    #[serde(skip_serializing_if = "Option::is_none")]
1779    /// Exitcode is 0 or 1
1780    pub exit_code: Option<i64>,
1781    #[serde(rename = "Output")]
1782    #[serde(skip_serializing_if = "Option::is_none")]
1783    /// Output is the stdout/stderr from the healthcheck command
1784    pub output: Option<String>,
1785    #[serde(rename = "Start")]
1786    #[serde(skip_serializing_if = "Option::is_none")]
1787    /// Start time as string
1788    pub start: Option<String>,
1789}
1790
1791/// HealthCheckOnFailureAction defines how Podman reacts when a container's health
1792/// status turns unhealthy.
1793pub type HealthCheckOnFailureAction = i64;
1794
1795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1796/// HealthCheckResults describes the results/logs from a healthcheck
1797pub struct HealthCheckResults {
1798    #[serde(rename = "FailingStreak")]
1799    #[serde(skip_serializing_if = "Option::is_none")]
1800    /// FailingStreak is the number of consecutive failed healthchecks
1801    pub failing_streak: Option<i64>,
1802    #[serde(rename = "Log")]
1803    #[serde(skip_serializing_if = "Option::is_none")]
1804    /// Log describes healthcheck attempts and results
1805    pub log: Option<Vec<HealthCheckLog>>,
1806    #[serde(rename = "Status")]
1807    #[serde(skip_serializing_if = "Option::is_none")]
1808    /// Status starting, healthy or unhealthy
1809    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    /// Retries is the number of consecutive failures needed to consider a container as unhealthy.
1819    /// Zero means inherit.
1820    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    /// Test is the test to perform to check that the container is healthy.
1826    /// An empty slice means to inherit the default.
1827    /// The options are:
1828    /// {} : inherit healthcheck
1829    /// {"NONE"} : disable healthcheck
1830    /// {"CMD", args...} : exec arguments directly
1831    /// {"CMD-SHELL", command} : run command with system's default shell
1832    pub test: Option<Vec<String>>,
1833    #[serde(rename = "Timeout")]
1834    pub timeout: Option<i64>,
1835}
1836
1837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1838/// HealthcheckResult stores information about a single run of a healthcheck probe
1839pub 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    /// Author is the author of the build point.
1858    pub author: Option<String>,
1859    #[serde(skip_serializing_if = "Option::is_none")]
1860    /// Comment is a custom message set when creating the layer.
1861    pub comment: Option<String>,
1862    #[serde(skip_serializing_if = "Option::is_none")]
1863    /// Created is the combined date and time at which the layer was created, formatted as defined by RFC 3339, section 5.6.
1864    pub created: Option<DateTime<Utc>>,
1865    #[serde(skip_serializing_if = "Option::is_none")]
1866    /// CreatedBy is the command which created the layer.
1867    pub created_by: Option<String>,
1868    #[serde(skip_serializing_if = "Option::is_none")]
1869    /// EmptyLayer is used to mark if the history item created a filesystem diff.
1870    pub empty_layer: Option<bool>,
1871}
1872
1873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1874/// HistoryResponse provides details on image layers
1875pub 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)]
1897/// HistoryResponseItem individual image layer information in response to ImageHistory operation
1898pub struct HistoryResponseItem {
1899    #[serde(rename = "Comment")]
1900    /// comment
1901    pub comment: String,
1902    #[serde(rename = "Created")]
1903    /// created
1904    pub created: i64,
1905    #[serde(rename = "CreatedBy")]
1906    /// created by
1907    pub created_by: String,
1908    #[serde(rename = "Id")]
1909    /// Id
1910    pub id: String,
1911    #[serde(rename = "Size")]
1912    /// size
1913    pub size: i64,
1914    #[serde(rename = "Tags")]
1915    #[serde(default)]
1916    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
1917    /// tags
1918    pub tags: Vec<String>,
1919}
1920
1921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1922/// Here, "non-portable" means "dependent of the host we are running on".
1923/// Portable information *should* appear in Config.
1924pub 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    /// Applicable to all platforms
1931    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    /// Applicable to UNIX platforms
1959    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    /// Applicable to Windows
1971    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    /// Applicable to all platforms
1990    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    /// Run a custom init inside the container, if null, use the daemon's configured settings
2030    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    /// KernelMemory specifies the kernel memory limit (in bytes) for the container.
2038    /// Deprecated: kernel 5.4 deprecated kmem.limit_in_bytes.
2039    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    /// MaskedPaths is the list of paths to be masked inside the container (this overrides the default set of paths)
2051    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    /// Mounts specs used by the container
2067    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    /// ReadonlyPaths is the list of paths to be set as read-only inside the container (this overrides the default set of paths)
2095    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)]
2135/// IDMap contains a single entry for user namespace range remapping. An array
2136/// of IDMap entries represents the structure that will be provided to the Linux
2137/// kernel for creating a user namespace.
2138pub 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)]
2148/// IDMappingOptions are used for specifying how ID mapping should be set up for
2149/// a layer or container.
2150pub 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    /// UIDMap and GIDMap are used for setting up a layer's root filesystem
2165    /// for use inside of a user namespace where ID mapping is being used.
2166    /// If HostUIDMapping/HostGIDMapping is true, no mapping of the
2167    /// respective type will be used.  Otherwise, if UIDMap and/or GIDMap
2168    /// contain at least one mapping, one or both will be used.  By default,
2169    /// if neither of those conditions apply, if the layer has a parent
2170    /// layer, the parent layer's mapping will be used, and if it does not
2171    /// have a parent layer, the mapping which was passed to the Store
2172    /// object when it was initialized will be used.
2173    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)]
2180/// IPAM represents IP Address Management
2181pub 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)]
2194/// IPAMConfig represents IPAM configurations
2195pub 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
2210/// See type IPNet and func ParseCIDR for details.
2211pub 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)]
2223/// IDResponse Response to an API call that returns just an Id
2224pub struct IdResponse {
2225    #[serde(rename = "Id")]
2226    /// The id of the newly created object.
2227    pub id: String,
2228}
2229
2230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2231/// OK (As of version 1.xx)
2232pub struct ImageBuild200Response {
2233    /// output from build process
2234    pub stream: String,
2235}
2236
2237pub type ImageBuildInputStreamParam = Vec<u8>;
2238
2239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2240/// OK (As of version 1.xx)
2241pub struct ImageBuildLibpod200Response {
2242    /// output from build process
2243    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    /// ArgsEscaped `[Deprecated]` - This field is present only for legacy
2251    /// compatibility with Docker and should not be used by new image builders.
2252    /// It is used by Docker for Windows images to indicate that the `Entrypoint`
2253    /// or `Cmd` or both, contains only a single element array, that is a
2254    /// pre-escaped, and combined into a single string `CommandLine`. If `true`
2255    /// the value in `Entrypoint` or `Cmd` should be used as-is to avoid double
2256    /// escaping.
2257    pub args_escaped: Option<bool>,
2258    #[serde(rename = "Cmd")]
2259    #[serde(skip_serializing_if = "Option::is_none")]
2260    /// Cmd defines the default arguments to the entrypoint of the container.
2261    pub cmd: Option<Vec<String>>,
2262    #[serde(rename = "Entrypoint")]
2263    #[serde(skip_serializing_if = "Option::is_none")]
2264    /// Entrypoint defines a list of arguments to use as the command to execute when the container starts.
2265    pub entrypoint: Option<Vec<String>>,
2266    #[serde(rename = "Env")]
2267    #[serde(skip_serializing_if = "Option::is_none")]
2268    /// Env is a list of environment variables to be used in a container.
2269    pub env: Option<Vec<String>>,
2270    #[serde(rename = "ExposedPorts")]
2271    #[serde(skip_serializing_if = "Option::is_none")]
2272    /// ExposedPorts a set of ports to expose from a container running this image.
2273    pub exposed_ports: Option<HashMap<String, Value>>,
2274    #[serde(rename = "Labels")]
2275    #[serde(skip_serializing_if = "Option::is_none")]
2276    /// Labels contains arbitrary metadata for the container.
2277    pub labels: Option<HashMap<String, String>>,
2278    #[serde(rename = "StopSignal")]
2279    #[serde(skip_serializing_if = "Option::is_none")]
2280    /// StopSignal contains the system call signal that will be sent to the container to exit.
2281    pub stop_signal: Option<String>,
2282    #[serde(rename = "User")]
2283    #[serde(skip_serializing_if = "Option::is_none")]
2284    /// User defines the username or UID which the process in the container should run as.
2285    pub user: Option<String>,
2286    #[serde(rename = "Volumes")]
2287    #[serde(skip_serializing_if = "Option::is_none")]
2288    /// Volumes is a set of directories describing where the process is likely write data specific to a container instance.
2289    pub volumes: Option<HashMap<String, Value>>,
2290    #[serde(rename = "WorkingDir")]
2291    #[serde(skip_serializing_if = "Option::is_none")]
2292    /// WorkingDir sets the current working directory of the entrypoint process in the container.
2293    pub working_dir: Option<String>,
2294}
2295
2296/// no error
2297pub 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)]
2370/// ImageDeleteResponseItem image delete response item
2371pub struct ImageDeleteResponseItem {
2372    #[serde(rename = "Deleted")]
2373    #[serde(skip_serializing_if = "Option::is_none")]
2374    /// The image ID of an image that was deleted
2375    pub deleted: Option<String>,
2376    #[serde(rename = "Untagged")]
2377    #[serde(skip_serializing_if = "Option::is_none")]
2378    /// The image ID of an image that was untagged
2379    pub untagged: Option<String>,
2380}
2381
2382/// no error
2383pub type ImageExportLibpod200Response = Vec<u8>;
2384
2385/// no error
2386pub type ImageGet200Response = Vec<u8>;
2387
2388/// no error
2389pub type ImageGetAll200Response = Vec<u8>;
2390
2391/// no error
2392pub 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    /// Architecture is the hardware CPU architecture that the image runs on.
2408    pub architecture: Option<String>,
2409    #[serde(rename = "Author")]
2410    #[serde(skip_serializing_if = "Option::is_none")]
2411    /// Author is the name of the author that was specified when committing the
2412    /// image, or as specified through MAINTAINER (deprecated) in the Dockerfile.
2413    pub author: Option<String>,
2414    #[serde(rename = "Comment")]
2415    #[serde(skip_serializing_if = "Option::is_none")]
2416    /// Comment is an optional message that can be set when committing or
2417    /// importing the image.
2418    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    /// Container is the ID of the container that was used to create the image.
2424    ///
2425    /// Depending on how the image was created, this field may be empty.
2426    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    /// Created is the date and time at which the image was created, formatted in
2432    /// RFC 3339 nano-seconds (time.RFC3339Nano).
2433    pub created: Option<String>,
2434    #[serde(rename = "DockerVersion")]
2435    #[serde(skip_serializing_if = "Option::is_none")]
2436    /// DockerVersion is the version of Docker that was used to build the image.
2437    ///
2438    /// Depending on how the image was created, this field may be empty.
2439    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    /// ID is the content-addressable ID of an image.
2445    ///
2446    /// This identifier is a content-addressable digest calculated from the
2447    /// image's configuration (which includes the digests of layers used by
2448    /// the image).
2449    ///
2450    /// Note that this digest differs from the `RepoDigests` below, which
2451    /// holds digests of image manifests that reference the image.
2452    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    /// OS is the Operating System the image is built to run on.
2458    pub os: Option<String>,
2459    #[serde(rename = "OsVersion")]
2460    #[serde(skip_serializing_if = "Option::is_none")]
2461    /// OsVersion is the version of the Operating System the image is built to
2462    /// run on (especially for Windows).
2463    pub os_version: Option<String>,
2464    #[serde(rename = "Parent")]
2465    #[serde(skip_serializing_if = "Option::is_none")]
2466    /// Parent is the ID of the parent image.
2467    ///
2468    /// Depending on how the image was created, this field may be empty and
2469    /// is only set for images that were built/created locally. This field
2470    /// is empty if the image was pulled from an image registry.
2471    pub parent: Option<String>,
2472    #[serde(rename = "RepoDigests")]
2473    #[serde(skip_serializing_if = "Option::is_none")]
2474    /// RepoDigests is a list of content-addressable digests of locally available
2475    /// image manifests that the image is referenced from. Multiple manifests can
2476    /// refer to the same image.
2477    ///
2478    /// These digests are usually only available if the image was either pulled
2479    /// from a registry, or if the image was pushed to a registry, which is when
2480    /// the manifest is generated and its digest calculated.
2481    pub repo_digests: Option<Vec<String>>,
2482    #[serde(rename = "RepoTags")]
2483    #[serde(skip_serializing_if = "Option::is_none")]
2484    /// RepoTags is a list of image names/tags in the local image cache that
2485    /// reference this image.
2486    ///
2487    /// Multiple image tags can refer to the same image, and this list may be
2488    /// empty if no tags reference the image, in which case the image is
2489    /// "untagged", in which case it can still be referenced by its ID.
2490    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    /// Size is the total size of the image including all layers it is composed of.
2496    pub size: Option<i64>,
2497    #[serde(rename = "Variant")]
2498    #[serde(skip_serializing_if = "Option::is_none")]
2499    /// Variant is the CPU architecture variant (presently ARM-only).
2500    pub variant: Option<String>,
2501    #[serde(rename = "VirtualSize")]
2502    #[serde(skip_serializing_if = "Option::is_none")]
2503    /// VirtualSize is the total size of the image including all layers it is
2504    /// composed of.
2505    ///
2506    /// In versions of Docker before v1.10, this field was calculated from
2507    /// the image itself and all of its parent images. Docker v1.10 and up
2508    /// store images self-contained, and no longer use a parent-chain, making
2509    /// this field an equivalent of the Size field.
2510    ///
2511    /// This field is kept for backward compatibility, but may be removed in
2512    /// a future version of the API.
2513    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)]
2528/// ImageMetadata contains engine-local data about the image
2529pub struct ImageMetadata {
2530    #[serde(rename = "LastTagTime")]
2531    #[serde(skip_serializing_if = "Option::is_none")]
2532    /// LastTagTime is the date and time at which the image was last tagged.
2533    pub last_tag_time: Option<DateTime<Utc>>,
2534}
2535
2536/// no error
2537pub type ImagePush200Response = Vec<u8>;
2538
2539/// no error
2540pub type ImagePushLibpod200Response = Vec<u8>;
2541
2542#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2543/// ImageSummary image summary
2544pub struct ImageSummary {
2545    #[serde(rename = "Containers")]
2546    /// Number of containers using this image. Includes both stopped and running
2547    /// containers.
2548    ///
2549    /// This size is not calculated by default, and depends on which API endpoint
2550    /// is used. `-1` indicates that the value has not been set / calculated.
2551    pub containers: i64,
2552    #[serde(rename = "Created")]
2553    /// Date and time at which the image was created as a Unix timestamp
2554    /// (number of seconds sinds EPOCH).
2555    pub created: i64,
2556    #[serde(rename = "Id")]
2557    /// ID is the content-addressable ID of an image.
2558    ///
2559    /// This identifier is a content-addressable digest calculated from the
2560    /// image's configuration (which includes the digests of layers used by
2561    /// the image).
2562    ///
2563    /// Note that this digest differs from the `RepoDigests` below, which
2564    /// holds digests of image manifests that reference the image.
2565    pub id: String,
2566    #[serde(rename = "Labels")]
2567    #[serde(default)]
2568    #[serde(deserialize_with = "deserialize_nonoptional_map")]
2569    /// User-defined key/value metadata.
2570    pub labels: HashMap<String, String>,
2571    #[serde(rename = "ParentId")]
2572    /// ID of the parent image.
2573    ///
2574    /// Depending on how the image was created, this field may be empty and
2575    /// is only set for images that were built/created locally. This field
2576    /// is empty if the image was pulled from an image registry.
2577    pub parent_id: String,
2578    #[serde(rename = "RepoDigests")]
2579    #[serde(default)]
2580    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
2581    /// List of content-addressable digests of locally available image manifests
2582    /// that the image is referenced from. Multiple manifests can refer to the
2583    /// same image.
2584    ///
2585    /// These digests are usually only available if the image was either pulled
2586    /// from a registry, or if the image was pushed to a registry, which is when
2587    /// the manifest is generated and its digest calculated.
2588    pub repo_digests: Vec<String>,
2589    #[serde(rename = "RepoTags")]
2590    #[serde(default)]
2591    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
2592    /// List of image names/tags in the local image cache that reference this
2593    /// image.
2594    ///
2595    /// Multiple image tags can refer to the same image, and this list may be
2596    /// empty if no tags reference the image, in which case the image is
2597    /// "untagged", in which case it can still be referenced by its ID.
2598    pub repo_tags: Vec<String>,
2599    #[serde(rename = "SharedSize")]
2600    /// Total size of image layers that are shared between this image and other
2601    /// images.
2602    ///
2603    /// This size is not calculated by default. `-1` indicates that the value
2604    /// has not been set / calculated.
2605    pub shared_size: i64,
2606    #[serde(rename = "Size")]
2607    /// Total size of the image including all layers it is composed of.
2608    pub size: i64,
2609    #[serde(rename = "VirtualSize")]
2610    /// Total size of the image including all layers it is composed of.
2611    ///
2612    /// In versions of Docker before v1.10, this field was calculated from
2613    /// the image itself and all of its parent images. Docker v1.10 and up
2614    /// store images self-contained, and no longer use a parent-chain, making
2615    /// this field an equivalent of the Size field.
2616    ///
2617    /// This field is kept for backward compatibility, but may be removed in
2618    /// a future version of the API.
2619    pub virtual_size: i64,
2620}
2621
2622#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2623/// ImageTreeReport provides results from ImageEngine.Tree()
2624pub 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)]
2631/// ImageVolume is a volume based on a container image.  The container image is
2632/// first mounted on the host and is then bind-mounted into the container.  An
2633/// ImageVolume is always mounted read-only.
2634pub struct ImageVolume {
2635    #[serde(rename = "Destination")]
2636    #[serde(skip_serializing_if = "Option::is_none")]
2637    /// Destination is the absolute path of the mount in the container.
2638    pub destination: Option<String>,
2639    #[serde(rename = "ReadWrite")]
2640    #[serde(skip_serializing_if = "Option::is_none")]
2641    /// ReadWrite sets the volume writable.
2642    pub read_write: Option<bool>,
2643    #[serde(rename = "Source")]
2644    #[serde(skip_serializing_if = "Option::is_none")]
2645    /// Source is the source of the image volume.  The image can be referred
2646    /// to by name and by ID.
2647    pub source: Option<String>,
2648}
2649
2650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2651/// Info contains information about the Volume as a whole as provided by
2652/// the CSI storage plugin.
2653pub struct Info {
2654    #[serde(rename = "AccessibleTopology")]
2655    #[serde(skip_serializing_if = "Option::is_none")]
2656    /// AccessibleTopolgoy is the topology this volume is actually accessible
2657    /// from.
2658    pub accessible_topology: Option<Vec<Topology>>,
2659    #[serde(rename = "CapacityBytes")]
2660    #[serde(skip_serializing_if = "Option::is_none")]
2661    /// CapacityBytes is the capacity of the volume in bytes. A value of 0
2662    /// indicates that the capacity is unknown.
2663    pub capacity_bytes: Option<i64>,
2664    #[serde(rename = "VolumeContext")]
2665    #[serde(skip_serializing_if = "Option::is_none")]
2666    /// VolumeContext is the context originating from the CSI storage plugin
2667    /// when the Volume is created.
2668    pub volume_context: Option<HashMap<String, String>>,
2669    #[serde(rename = "VolumeID")]
2670    #[serde(skip_serializing_if = "Option::is_none")]
2671    /// VolumeID is the ID of the Volume as seen by the CSI storage plugin. This
2672    /// is distinct from the Volume's Swarm ID, which is the ID used by all of
2673    /// the Docker Engine to refer to the Volume. If this field is blank, then
2674    /// the Volume has not been successfully created yet.
2675    pub volume_id: Option<String>,
2676}
2677
2678#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2679/// InspectAdditionalNetwork holds information about non-default networks the
2680/// container has been connected to.
2681/// As with InspectNetworkSettings, many fields are unused and maintained only
2682/// for compatibility with Docker.
2683pub struct InspectAdditionalNetwork {
2684    #[serde(rename = "AdditionalMACAddresses")]
2685    #[serde(skip_serializing_if = "Option::is_none")]
2686    /// AdditionalMacAddresses is a set of additional MAC Addresses beyond
2687    /// the first. CNI may configure more than one interface for a single
2688    /// network, which can cause this.
2689    pub additional_mac_addresses: Option<Vec<String>>,
2690    #[serde(rename = "Aliases")]
2691    #[serde(skip_serializing_if = "Option::is_none")]
2692    /// Aliases are any network aliases the container has in this network.
2693    pub aliases: Option<Vec<String>>,
2694    #[serde(rename = "DriverOpts")]
2695    #[serde(skip_serializing_if = "Option::is_none")]
2696    /// DriverOpts is presently unused and maintained exclusively for
2697    /// compatibility.
2698    pub driver_opts: Option<HashMap<String, String>>,
2699    #[serde(rename = "EndpointID")]
2700    #[serde(skip_serializing_if = "Option::is_none")]
2701    /// EndpointID is unused, maintained exclusively for compatibility.
2702    pub endpoint_id: Option<String>,
2703    #[serde(rename = "Gateway")]
2704    #[serde(skip_serializing_if = "Option::is_none")]
2705    /// Gateway is the IP address of the gateway this network will use.
2706    pub gateway: Option<String>,
2707    #[serde(rename = "GlobalIPv6Address")]
2708    #[serde(skip_serializing_if = "Option::is_none")]
2709    /// GlobalIPv6Address is the global-scope IPv6 Address for this network.
2710    pub global_i_pv_6_address: Option<String>,
2711    #[serde(rename = "GlobalIPv6PrefixLen")]
2712    #[serde(skip_serializing_if = "Option::is_none")]
2713    /// GlobalIPv6PrefixLen is the length of the subnet mask of this network.
2714    pub global_i_pv_6_prefix_len: Option<i64>,
2715    #[serde(rename = "IPAMConfig")]
2716    #[serde(skip_serializing_if = "Option::is_none")]
2717    /// IPAMConfig is presently unused and maintained exclusively for
2718    /// compatibility.
2719    pub ipam_config: Option<HashMap<String, String>>,
2720    #[serde(rename = "IPAddress")]
2721    #[serde(skip_serializing_if = "Option::is_none")]
2722    /// IPAddress is the IP address for this network.
2723    pub ip_address: Option<String>,
2724    #[serde(rename = "IPPrefixLen")]
2725    #[serde(skip_serializing_if = "Option::is_none")]
2726    /// IPPrefixLen is the length of the subnet mask of this network.
2727    pub ip_prefix_len: Option<i64>,
2728    #[serde(rename = "IPv6Gateway")]
2729    #[serde(skip_serializing_if = "Option::is_none")]
2730    /// IPv6Gateway is the IPv6 gateway this network will use.
2731    pub i_pv_6_gateway: Option<String>,
2732    #[serde(rename = "Links")]
2733    #[serde(skip_serializing_if = "Option::is_none")]
2734    /// Links is presently unused and maintained exclusively for
2735    /// compatibility.
2736    pub links: Option<Vec<String>>,
2737    #[serde(rename = "MacAddress")]
2738    #[serde(skip_serializing_if = "Option::is_none")]
2739    /// MacAddress is the MAC address for the interface in this network.
2740    pub mac_address: Option<String>,
2741    #[serde(rename = "NetworkID")]
2742    #[serde(skip_serializing_if = "Option::is_none")]
2743    /// Name of the network we're connecting to.
2744    pub network_id: Option<String>,
2745    #[serde(rename = "SecondaryIPAddresses")]
2746    #[serde(skip_serializing_if = "Option::is_none")]
2747    /// SecondaryIPAddresses is a list of extra IP Addresses that the
2748    /// container has been assigned in this network.
2749    pub secondary_ip_addresses: Option<Vec<Address>>,
2750    #[serde(rename = "SecondaryIPv6Addresses")]
2751    #[serde(skip_serializing_if = "Option::is_none")]
2752    /// SecondaryIPv6Addresses is a list of extra IPv6 Addresses that the
2753    /// container has been assigned in this network.
2754    pub secondary_i_pv_6_addresses: Option<Vec<Address>>,
2755}
2756
2757#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2758/// InspectBlkioThrottleDevice holds information about a speed cap for a device
2759/// node. This cap applies to a specific operation (read, write, etc) on the given
2760/// node.
2761pub struct InspectBlkioThrottleDevice {
2762    #[serde(rename = "Path")]
2763    #[serde(skip_serializing_if = "Option::is_none")]
2764    /// Path is the path to the device this applies to.
2765    pub path: Option<String>,
2766    #[serde(rename = "Rate")]
2767    #[serde(skip_serializing_if = "Option::is_none")]
2768    /// Rate is the maximum rate. It is in either bytes per second or iops
2769    /// per second, determined by where it is used - documentation will
2770    /// indicate which is appropriate.
2771    pub rate: Option<u64>,
2772}
2773
2774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2775/// InspectBlkioWeightDevice holds information about the relative weight
2776/// of an individual device node. Weights are used in the I/O scheduler to give
2777/// relative priority to some accesses.
2778pub struct InspectBlkioWeightDevice {
2779    #[serde(rename = "Path")]
2780    #[serde(skip_serializing_if = "Option::is_none")]
2781    /// Path is the path to the device this applies to.
2782    pub path: Option<String>,
2783    #[serde(rename = "Weight")]
2784    #[serde(skip_serializing_if = "Option::is_none")]
2785    /// Weight is the relative weight the scheduler will use when scheduling
2786    /// I/O.
2787    pub weight: Option<u16>,
2788}
2789
2790#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2791/// InspectContainerConfig holds further data about how a container was initially
2792/// configured.
2793pub struct InspectContainerConfig {
2794    #[serde(rename = "Annotations")]
2795    #[serde(skip_serializing_if = "Option::is_none")]
2796    /// Container annotations
2797    pub annotations: Option<HashMap<String, String>>,
2798    #[serde(rename = "AttachStderr")]
2799    #[serde(skip_serializing_if = "Option::is_none")]
2800    /// Unused, at present
2801    pub attach_stderr: Option<bool>,
2802    #[serde(rename = "AttachStdin")]
2803    #[serde(skip_serializing_if = "Option::is_none")]
2804    /// Unused, at present
2805    pub attach_stdin: Option<bool>,
2806    #[serde(rename = "AttachStdout")]
2807    #[serde(skip_serializing_if = "Option::is_none")]
2808    /// Unused, at present
2809    pub attach_stdout: Option<bool>,
2810    #[serde(rename = "ChrootDirs")]
2811    #[serde(skip_serializing_if = "Option::is_none")]
2812    /// ChrootDirs is an additional set of directories that need to be
2813    /// treated as root directories. Standard bind mounts will be mounted
2814    /// into paths relative to these directories.
2815    pub chroot_dirs: Option<Vec<String>>,
2816    #[serde(rename = "Cmd")]
2817    #[serde(skip_serializing_if = "Option::is_none")]
2818    /// Container command
2819    pub cmd: Option<Vec<String>>,
2820    #[serde(rename = "CreateCommand")]
2821    #[serde(skip_serializing_if = "Option::is_none")]
2822    /// CreateCommand is the full command plus arguments of the process the
2823    /// container has been created with.
2824    pub create_command: Option<Vec<String>>,
2825    #[serde(rename = "Domainname")]
2826    #[serde(skip_serializing_if = "Option::is_none")]
2827    /// Container domain name - unused at present
2828    pub domainname: Option<String>,
2829    #[serde(rename = "Entrypoint")]
2830    #[serde(skip_serializing_if = "Option::is_none")]
2831    /// Container entrypoint
2832    pub entrypoint: Option<String>,
2833    #[serde(rename = "Env")]
2834    #[serde(skip_serializing_if = "Option::is_none")]
2835    /// Container environment variables
2836    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    /// HealthcheckOnFailureAction defines an action to take once the container turns unhealthy.
2842    pub healthcheck_on_failure_action: Option<String>,
2843    #[serde(rename = "Hostname")]
2844    #[serde(skip_serializing_if = "Option::is_none")]
2845    /// Container hostname
2846    pub hostname: Option<String>,
2847    #[serde(rename = "Image")]
2848    #[serde(skip_serializing_if = "Option::is_none")]
2849    /// Container image
2850    pub image: Option<String>,
2851    #[serde(rename = "Labels")]
2852    #[serde(skip_serializing_if = "Option::is_none")]
2853    /// Container labels
2854    pub labels: Option<HashMap<String, String>>,
2855    #[serde(rename = "OnBuild")]
2856    #[serde(skip_serializing_if = "Option::is_none")]
2857    /// On-build arguments - presently unused. More of Buildah's domain.
2858    pub on_build: Option<String>,
2859    #[serde(rename = "OpenStdin")]
2860    #[serde(skip_serializing_if = "Option::is_none")]
2861    /// Whether the container leaves STDIN open
2862    pub open_stdin: Option<bool>,
2863    #[serde(rename = "Passwd")]
2864    #[serde(skip_serializing_if = "Option::is_none")]
2865    /// Passwd determines whether or not podman can add entries to /etc/passwd and /etc/group
2866    pub passwd: Option<bool>,
2867    #[serde(rename = "Secrets")]
2868    #[serde(skip_serializing_if = "Option::is_none")]
2869    /// Secrets are the secrets mounted in the container
2870    pub secrets: Option<Vec<InspectSecret>>,
2871    #[serde(rename = "StdinOnce")]
2872    #[serde(skip_serializing_if = "Option::is_none")]
2873    /// Whether STDIN is only left open once.
2874    /// Presently not supported by Podman, unused.
2875    pub stdin_once: Option<bool>,
2876    #[serde(rename = "StopSignal")]
2877    #[serde(skip_serializing_if = "Option::is_none")]
2878    /// Container stop signal
2879    pub stop_signal: Option<u64>,
2880    #[serde(rename = "StopTimeout")]
2881    #[serde(skip_serializing_if = "Option::is_none")]
2882    /// StopTimeout is time before container is stopped when calling stop
2883    pub stop_timeout: Option<u64>,
2884    #[serde(rename = "SystemdMode")]
2885    #[serde(skip_serializing_if = "Option::is_none")]
2886    /// SystemdMode is whether the container is running in systemd mode. In
2887    /// systemd mode, the container configuration is customized to optimize
2888    /// running systemd in the container.
2889    pub systemd_mode: Option<bool>,
2890    #[serde(rename = "Timeout")]
2891    #[serde(skip_serializing_if = "Option::is_none")]
2892    /// Timeout is time before container is killed by conmon
2893    pub timeout: Option<u64>,
2894    #[serde(rename = "Timezone")]
2895    #[serde(skip_serializing_if = "Option::is_none")]
2896    /// Timezone is the timezone inside the container.
2897    /// Local means it has the same timezone as the host machine
2898    pub timezone: Option<String>,
2899    #[serde(rename = "Tty")]
2900    #[serde(skip_serializing_if = "Option::is_none")]
2901    /// Whether the container creates a TTY
2902    pub tty: Option<bool>,
2903    #[serde(rename = "Umask")]
2904    #[serde(skip_serializing_if = "Option::is_none")]
2905    /// Umask is the umask inside the container.
2906    pub umask: Option<String>,
2907    #[serde(rename = "User")]
2908    #[serde(skip_serializing_if = "Option::is_none")]
2909    /// User the container was launched with
2910    pub user: Option<String>,
2911    #[serde(rename = "Volumes")]
2912    #[serde(skip_serializing_if = "Option::is_none")]
2913    /// Unused, at present. I've never seen this field populated.
2914    pub volumes: Option<HashMap<String, Value>>,
2915    #[serde(rename = "WorkingDir")]
2916    #[serde(skip_serializing_if = "Option::is_none")]
2917    /// Container working directory
2918    pub working_dir: Option<String>,
2919    #[serde(rename = "sdNotifyMode")]
2920    #[serde(skip_serializing_if = "Option::is_none")]
2921    /// SdNotifyMode is the sd-notify mode of the container.
2922    pub sd_notify_mode: Option<String>,
2923    #[serde(rename = "sdNotifySocket")]
2924    #[serde(skip_serializing_if = "Option::is_none")]
2925    /// SdNotifySocket is the NOTIFY_SOCKET in use by/configured for the container.
2926    pub sd_notify_socket: Option<String>,
2927}
2928
2929#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2930/// InspectContainerData provides a detailed record of a container's configuration
2931/// and state as viewed by Libpod.
2932/// Large portions of this structure are defined such that the output is
2933/// compatible with `docker inspect` JSON, but additional fields have been added
2934/// as required to share information not in the original output.
2935pub 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)]
3048/// nolint:revive,stylecheck // Field names are fixed for compatibility and cannot be changed.
3049pub struct InspectContainerHostConfig {
3050    #[serde(rename = "AutoRemove")]
3051    #[serde(skip_serializing_if = "Option::is_none")]
3052    /// AutoRemove is whether the container will be automatically removed on
3053    /// exiting.
3054    /// It is not handled directly within libpod and is stored in an
3055    /// annotation.
3056    pub auto_remove: Option<bool>,
3057    #[serde(rename = "Binds")]
3058    #[serde(skip_serializing_if = "Option::is_none")]
3059    /// Binds contains an array of user-added mounts.
3060    /// Both volume mounts and named volumes are included.
3061    /// Tmpfs mounts are NOT included.
3062    /// In 'docker inspect' this is separated into 'Binds' and 'Mounts' based
3063    /// on how a mount was added. We do not make this distinction and do not
3064    /// include a Mounts field in inspect.
3065    /// Format: <src>:<destination>[:<comma-separated options>]
3066    pub binds: Option<Vec<String>>,
3067    #[serde(rename = "BlkioDeviceReadBps")]
3068    #[serde(skip_serializing_if = "Option::is_none")]
3069    /// BlkioDeviceReadBps is an array of I/O throttle parameters for
3070    /// individual device nodes.
3071    /// This specifically sets read rate cap in bytes per second for device
3072    /// nodes.
3073    /// As with BlkioWeightDevice, we pull the path from /sys/dev, and we
3074    /// don't guarantee the path will be identical to the original (though
3075    /// the node will be).
3076    pub blkio_device_read_bps: Option<Vec<InspectBlkioThrottleDevice>>,
3077    #[serde(rename = "BlkioDeviceReadIOps")]
3078    #[serde(skip_serializing_if = "Option::is_none")]
3079    /// BlkioDeviceReadIOps is an array of I/O throttle parameters for
3080    /// individual device nodes.
3081    /// This specifically sets the read rate cap in iops per second for
3082    /// device nodes.
3083    /// As with BlkioWeightDevice, we pull the path from /sys/dev, and we
3084    /// don't guarantee the path will be identical to the original (though
3085    /// the node will be).
3086    pub blkio_device_read_i_ops: Option<Vec<InspectBlkioThrottleDevice>>,
3087    #[serde(rename = "BlkioDeviceWriteBps")]
3088    #[serde(skip_serializing_if = "Option::is_none")]
3089    /// BlkioDeviceWriteBps is an array of I/O throttle parameters for
3090    /// individual device nodes.
3091    /// this specifically sets write rate cap in bytes per second for device
3092    /// nodes.
3093    /// as with BlkioWeightDevice, we pull the path from /sys/dev, and we
3094    /// don't guarantee the path will be identical to the original (though
3095    /// the node will be).
3096    pub blkio_device_write_bps: Option<Vec<InspectBlkioThrottleDevice>>,
3097    #[serde(rename = "BlkioDeviceWriteIOps")]
3098    #[serde(skip_serializing_if = "Option::is_none")]
3099    /// BlkioDeviceWriteIOps is an array of I/O throttle parameters for
3100    /// individual device nodes.
3101    /// This specifically sets the write rate cap in iops per second for
3102    /// device nodes.
3103    /// As with BlkioWeightDevice, we pull the path from /sys/dev, and we
3104    /// don't guarantee the path will be identical to the original (though
3105    /// the node will be).
3106    pub blkio_device_write_i_ops: Option<Vec<InspectBlkioThrottleDevice>>,
3107    #[serde(rename = "BlkioWeight")]
3108    #[serde(skip_serializing_if = "Option::is_none")]
3109    /// BlkioWeight indicates the I/O resources allocated to the container.
3110    /// It is a relative weight in the scheduler for assigning I/O time
3111    /// versus other Cgroups.
3112    pub blkio_weight: Option<u16>,
3113    #[serde(rename = "BlkioWeightDevice")]
3114    #[serde(skip_serializing_if = "Option::is_none")]
3115    /// BlkioWeightDevice is an array of I/O resource priorities for
3116    /// individual device nodes.
3117    /// Unfortunately, the spec only stores the device's Major/Minor numbers
3118    /// and not the path, which is used here.
3119    /// Fortunately, the kernel provides an interface for retrieving the path
3120    /// of a given node by major:minor at /sys/dev/. However, the exact path
3121    /// in use may not be what was used in the original CLI invocation -
3122    /// though it is guaranteed that the device node will be the same, and
3123    /// using the given path will be functionally identical.
3124    pub blkio_weight_device: Option<Vec<InspectBlkioWeightDevice>>,
3125    #[serde(rename = "CapAdd")]
3126    #[serde(skip_serializing_if = "Option::is_none")]
3127    /// CapAdd is a list of capabilities added to the container.
3128    /// It is not directly stored by Libpod, and instead computed from the
3129    /// capabilities listed in the container's spec, compared against a set
3130    /// of default capabilities.
3131    pub cap_add: Option<Vec<String>>,
3132    #[serde(rename = "CapDrop")]
3133    #[serde(skip_serializing_if = "Option::is_none")]
3134    /// CapDrop is a list of capabilities removed from the container.
3135    /// It is not directly stored by libpod, and instead computed from the
3136    /// capabilities listed in the container's spec, compared against a set
3137    /// of default capabilities.
3138    pub cap_drop: Option<Vec<String>>,
3139    #[serde(rename = "Cgroup")]
3140    #[serde(skip_serializing_if = "Option::is_none")]
3141    /// Cgroup contains the container's cgroup. It is presently not
3142    /// populated.
3143    /// TODO.
3144    pub cgroup: Option<String>,
3145    #[serde(rename = "CgroupConf")]
3146    #[serde(skip_serializing_if = "Option::is_none")]
3147    /// CgroupConf is the configuration for cgroup v2.
3148    pub cgroup_conf: Option<HashMap<String, String>>,
3149    #[serde(rename = "CgroupManager")]
3150    #[serde(skip_serializing_if = "Option::is_none")]
3151    /// CgroupManager is the cgroup manager used by the container.
3152    /// At present, allowed values are either "cgroupfs" or "systemd".
3153    pub cgroup_manager: Option<String>,
3154    #[serde(rename = "CgroupMode")]
3155    #[serde(skip_serializing_if = "Option::is_none")]
3156    /// CgroupMode is the configuration of the container's cgroup namespace.
3157    /// Populated as follows:
3158    /// private - a cgroup namespace has been created
3159    /// host - No cgroup namespace created
3160    /// container:<id> - Using another container's cgroup namespace
3161    /// ns:<path> - A path to a cgroup namespace has been specified
3162    pub cgroup_mode: Option<String>,
3163    #[serde(rename = "CgroupParent")]
3164    #[serde(skip_serializing_if = "Option::is_none")]
3165    /// CgroupParent is the Cgroup parent of the container.
3166    /// Only set if not default.
3167    pub cgroup_parent: Option<String>,
3168    #[serde(rename = "Cgroups")]
3169    #[serde(skip_serializing_if = "Option::is_none")]
3170    /// Cgroups contains the container's Cgroup mode.
3171    /// Allowed values are "default" (container is creating Cgroups) and
3172    /// "disabled" (container is not creating Cgroups).
3173    /// This is Libpod-specific and not included in `docker inspect`.
3174    pub cgroups: Option<String>,
3175    #[serde(rename = "ConsoleSize")]
3176    #[serde(skip_serializing_if = "Option::is_none")]
3177    /// ConsoleSize is an array of 2 integers showing the size of the
3178    /// container's console.
3179    /// It is only set if the container is creating a terminal.
3180    /// TODO.
3181    pub console_size: Option<Vec<u64>>,
3182    #[serde(rename = "ContainerIDFile")]
3183    #[serde(skip_serializing_if = "Option::is_none")]
3184    /// ContainerIDFile is a file created during container creation to hold
3185    /// the ID of the created container.
3186    /// This is not handled within libpod and is stored in an annotation.
3187    pub container_id_file: Option<String>,
3188    #[serde(rename = "CpuCount")]
3189    #[serde(skip_serializing_if = "Option::is_none")]
3190    /// CpuCount is Windows-only and not presently implemented.
3191    pub cpu_count: Option<u64>,
3192    #[serde(rename = "CpuPercent")]
3193    #[serde(skip_serializing_if = "Option::is_none")]
3194    /// CpuPercent is Windows-only and not presently implemented.
3195    pub cpu_percent: Option<u64>,
3196    #[serde(rename = "CpuPeriod")]
3197    #[serde(skip_serializing_if = "Option::is_none")]
3198    /// CpuPeriod is the length of a CPU period in microseconds.
3199    /// It relates directly to CpuQuota.
3200    pub cpu_period: Option<u64>,
3201    #[serde(rename = "CpuQuota")]
3202    #[serde(skip_serializing_if = "Option::is_none")]
3203    /// CpuPeriod is the amount of time (in microseconds) that a container
3204    /// can use the CPU in every CpuPeriod.
3205    pub cpu_quota: Option<i64>,
3206    #[serde(rename = "CpuRealtimePeriod")]
3207    #[serde(skip_serializing_if = "Option::is_none")]
3208    /// CpuRealtimePeriod is the length of time (in microseconds) of the CPU
3209    /// realtime period. If set to 0, no time will be allocated to realtime
3210    /// tasks.
3211    pub cpu_realtime_period: Option<u64>,
3212    #[serde(rename = "CpuRealtimeRuntime")]
3213    #[serde(skip_serializing_if = "Option::is_none")]
3214    /// CpuRealtimeRuntime is the length of time (in microseconds) allocated
3215    /// for realtime tasks within every CpuRealtimePeriod.
3216    pub cpu_realtime_runtime: Option<i64>,
3217    #[serde(rename = "CpuShares")]
3218    #[serde(skip_serializing_if = "Option::is_none")]
3219    /// CpuShares indicates the CPU resources allocated to the container.
3220    /// It is a relative weight in the scheduler for assigning CPU time
3221    /// versus other Cgroups.
3222    pub cpu_shares: Option<u64>,
3223    #[serde(rename = "CpusetCpus")]
3224    #[serde(skip_serializing_if = "Option::is_none")]
3225    /// CpusetCpus is the set of CPUs that the container will execute on.
3226    /// Formatted as `0-3` or `0,2`. Default (if unset) is all CPUs.
3227    pub cpuset_cpus: Option<String>,
3228    #[serde(rename = "CpusetMems")]
3229    #[serde(skip_serializing_if = "Option::is_none")]
3230    /// CpusetMems is the set of memory nodes the container will use.
3231    /// Formatted as `0-3` or `0,2`. Default (if unset) is all memory nodes.
3232    pub cpuset_mems: Option<String>,
3233    #[serde(rename = "Devices")]
3234    #[serde(skip_serializing_if = "Option::is_none")]
3235    /// Devices is a list of device nodes that will be added to the
3236    /// container.
3237    /// These are stored in the OCI spec only as type, major, minor while we
3238    /// display the host path. We convert this with /sys/dev, but we cannot
3239    /// guarantee that the host path will be identical - only that the actual
3240    /// device will be.
3241    pub devices: Option<Vec<InspectDevice>>,
3242    #[serde(rename = "DiskQuota")]
3243    #[serde(skip_serializing_if = "Option::is_none")]
3244    /// DiskQuota is the maximum amount of disk space the container may use
3245    /// (in bytes).
3246    /// Presently not populated.
3247    /// TODO.
3248    pub disk_quota: Option<u64>,
3249    #[serde(rename = "Dns")]
3250    #[serde(skip_serializing_if = "Option::is_none")]
3251    /// Dns is a list of DNS nameservers that will be added to the
3252    /// container's resolv.conf
3253    pub dns: Option<Vec<String>>,
3254    #[serde(rename = "DnsOptions")]
3255    #[serde(skip_serializing_if = "Option::is_none")]
3256    /// DnsOptions is a list of DNS options that will be set in the
3257    /// container's resolv.conf
3258    pub dns_options: Option<Vec<String>>,
3259    #[serde(rename = "DnsSearch")]
3260    #[serde(skip_serializing_if = "Option::is_none")]
3261    /// DnsSearch is a list of DNS search domains that will be set in the
3262    /// container's resolv.conf
3263    pub dns_search: Option<Vec<String>>,
3264    #[serde(rename = "ExtraHosts")]
3265    #[serde(skip_serializing_if = "Option::is_none")]
3266    /// ExtraHosts contains hosts that will be added to the container's
3267    /// etc/hosts.
3268    pub extra_hosts: Option<Vec<String>>,
3269    #[serde(rename = "GroupAdd")]
3270    #[serde(skip_serializing_if = "Option::is_none")]
3271    /// GroupAdd contains groups that the user inside the container will be
3272    /// added to.
3273    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    /// IOMaximumBandwidth is Windows-only and not presently implemented.
3279    pub io_maximum_bandwidth: Option<u64>,
3280    #[serde(rename = "IOMaximumIOps")]
3281    #[serde(skip_serializing_if = "Option::is_none")]
3282    /// IOMaximumIOps is Windows-only and not presently implemented.
3283    pub io_maximum_i_ops: Option<u64>,
3284    #[serde(rename = "Init")]
3285    #[serde(skip_serializing_if = "Option::is_none")]
3286    /// Init indicates whether the container has an init mounted into it.
3287    pub init: Option<bool>,
3288    #[serde(rename = "IpcMode")]
3289    #[serde(skip_serializing_if = "Option::is_none")]
3290    /// IpcMode represents the configuration of the container's IPC
3291    /// namespace.
3292    /// Populated as follows:
3293    /// "" (empty string) - Default, an IPC namespace will be created
3294    /// host - No IPC namespace created
3295    /// container:<id> - Using another container's IPC namespace
3296    /// ns:<path> - A path to an IPC namespace has been specified
3297    pub ipc_mode: Option<String>,
3298    #[serde(rename = "Isolation")]
3299    #[serde(skip_serializing_if = "Option::is_none")]
3300    /// Isolation is presently unused and provided solely for Docker
3301    /// compatibility.
3302    pub isolation: Option<String>,
3303    #[serde(rename = "KernelMemory")]
3304    #[serde(skip_serializing_if = "Option::is_none")]
3305    /// KernelMemory is the maximum amount of memory the kernel will devote
3306    /// to the container.
3307    pub kernel_memory: Option<i64>,
3308    #[serde(rename = "Links")]
3309    #[serde(skip_serializing_if = "Option::is_none")]
3310    /// Links is unused, and provided purely for Docker compatibility.
3311    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    /// Memory indicates the memory resources allocated to the container.
3317    /// This is the limit (in bytes) of RAM the container may use.
3318    pub memory: Option<i64>,
3319    #[serde(rename = "MemoryReservation")]
3320    #[serde(skip_serializing_if = "Option::is_none")]
3321    /// MemoryReservation is the reservation (soft limit) of memory available
3322    /// to the container. Soft limits are warnings only and can be exceeded.
3323    pub memory_reservation: Option<i64>,
3324    #[serde(rename = "MemorySwap")]
3325    #[serde(skip_serializing_if = "Option::is_none")]
3326    /// MemorySwap is the total limit for all memory available to the
3327    /// container, including swap. 0 indicates that there is no limit to the
3328    /// amount of memory available.
3329    pub memory_swap: Option<i64>,
3330    #[serde(rename = "MemorySwappiness")]
3331    #[serde(skip_serializing_if = "Option::is_none")]
3332    /// MemorySwappiness is the willingness of the kernel to page container
3333    /// memory to swap. It is an integer from 0 to 100, with low numbers
3334    /// being more likely to be put into swap.
3335    /// 1, the default, will not set swappiness and use the system defaults.
3336    pub memory_swappiness: Option<i64>,
3337    #[serde(rename = "NanoCpus")]
3338    #[serde(skip_serializing_if = "Option::is_none")]
3339    /// NanoCpus indicates number of CPUs allocated to the container.
3340    /// It is an integer where one full CPU is indicated by 1000000000 (one
3341    /// billion).
3342    /// Thus, 2.5 CPUs (fractional portions of CPUs are allowed) would be
3343    /// 2500000000 (2.5 billion).
3344    /// In 'docker inspect' this is set exclusively of two further options in
3345    /// the output (CpuPeriod and CpuQuota) which are both used to implement
3346    /// this functionality.
3347    /// We can't distinguish here, so if CpuQuota is set to the default of
3348    /// 100000, we will set both CpuQuota, CpuPeriod, and NanoCpus. If
3349    /// CpuQuota is not the default, we will not set NanoCpus.
3350    pub nano_cpus: Option<i64>,
3351    #[serde(rename = "NetworkMode")]
3352    #[serde(skip_serializing_if = "Option::is_none")]
3353    /// NetworkMode is the configuration of the container's network
3354    /// namespace.
3355    /// Populated as follows:
3356    /// default - A network namespace is being created and configured via CNI
3357    /// none - A network namespace is being created, not configured via CNI
3358    /// host - No network namespace created
3359    /// container:<id> - Using another container's network namespace
3360    /// ns:<path> - A path to a network namespace has been specified
3361    pub network_mode: Option<String>,
3362    #[serde(rename = "OomKillDisable")]
3363    #[serde(skip_serializing_if = "Option::is_none")]
3364    /// OomKillDisable indicates whether the kernel OOM killer is disabled
3365    /// for the container.
3366    pub oom_kill_disable: Option<bool>,
3367    #[serde(rename = "OomScoreAdj")]
3368    #[serde(skip_serializing_if = "Option::is_none")]
3369    /// OOMScoreAdj is an adjustment that will be made to the container's OOM
3370    /// score.
3371    pub oom_score_adj: Option<i64>,
3372    #[serde(rename = "PidMode")]
3373    #[serde(skip_serializing_if = "Option::is_none")]
3374    /// PidMode represents the configuration of the container's PID
3375    /// namespace.
3376    /// Populated as follows:
3377    /// "" (empty string) - Default, a PID namespace will be created
3378    /// host - No PID namespace created
3379    /// container:<id> - Using another container's PID namespace
3380    /// ns:<path> - A path to a PID namespace has been specified
3381    pub pid_mode: Option<String>,
3382    #[serde(rename = "PidsLimit")]
3383    #[serde(skip_serializing_if = "Option::is_none")]
3384    /// PidsLimit is the maximum number of PIDs that may be created within
3385    /// the container. 0, the default, indicates no limit.
3386    pub pids_limit: Option<i64>,
3387    #[serde(rename = "PortBindings")]
3388    #[serde(skip_serializing_if = "Option::is_none")]
3389    /// PortBindings contains the container's port bindings.
3390    /// It is formatted as map[string][]InspectHostPort.
3391    /// The string key here is formatted as <integer port number>/<protocol>
3392    /// and represents the container port. A single container port may be
3393    /// bound to multiple host ports (on different IPs).
3394    pub port_bindings: Option<HashMap<String, Option<Vec<InspectHostPort>>>>,
3395    #[serde(rename = "Privileged")]
3396    #[serde(skip_serializing_if = "Option::is_none")]
3397    /// Privileged indicates whether the container is running with elevated
3398    /// privileges.
3399    /// This has a very specific meaning in the Docker sense, so it's very
3400    /// difficult to decode from the spec and config, and so is stored as an
3401    /// annotation.
3402    pub privileged: Option<bool>,
3403    #[serde(rename = "PublishAllPorts")]
3404    #[serde(skip_serializing_if = "Option::is_none")]
3405    /// PublishAllPorts indicates whether image ports are being published.
3406    /// This is not directly stored in libpod and is saved as an annotation.
3407    pub publish_all_ports: Option<bool>,
3408    #[serde(rename = "ReadonlyRootfs")]
3409    #[serde(skip_serializing_if = "Option::is_none")]
3410    /// ReadonlyRootfs is whether the container will be mounted read-only.
3411    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    /// Runtime is provided purely for Docker compatibility.
3417    /// It is set unconditionally to "oci" as Podman does not presently
3418    /// support non-OCI runtimes.
3419    pub runtime: Option<String>,
3420    #[serde(rename = "SecurityOpt")]
3421    #[serde(skip_serializing_if = "Option::is_none")]
3422    /// SecurityOpt is a list of security-related options that are set in the
3423    /// container.
3424    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    /// Tmpfs is a list of tmpfs filesystems that will be mounted into the
3431    /// container.
3432    /// It is a map of destination path to options for the mount.
3433    pub tmpfs: Option<HashMap<String, String>>,
3434    #[serde(rename = "UTSMode")]
3435    #[serde(skip_serializing_if = "Option::is_none")]
3436    /// UTSMode represents the configuration of the container's UID
3437    /// namespace.
3438    /// Populated as follows:
3439    /// "" (empty string) - Default, a UTS namespace will be created
3440    /// host - no UTS namespace created
3441    /// container:<id> - Using another container's UTS namespace
3442    /// ns:<path> - A path to a UTS namespace has been specified
3443    pub uts_mode: Option<String>,
3444    #[serde(rename = "Ulimits")]
3445    #[serde(skip_serializing_if = "Option::is_none")]
3446    /// Ulimits is a set of ulimits that will be set within the container.
3447    pub ulimits: Option<Vec<InspectUlimit>>,
3448    #[serde(rename = "UsernsMode")]
3449    #[serde(skip_serializing_if = "Option::is_none")]
3450    /// UsernsMode represents the configuration of the container's user
3451    /// namespace.
3452    /// When running rootless, a user namespace is created outside of libpod
3453    /// to allow some privileged operations. This will not be reflected here.
3454    /// Populated as follows:
3455    /// "" (empty string) - No user namespace will be created
3456    /// private - The container will be run in a user namespace
3457    /// container:<id> - Using another container's user namespace
3458    /// ns:<path> - A path to a user namespace has been specified
3459    /// TODO Rootless has an additional 'keep-id' option, presently not
3460    /// reflected here.
3461    pub userns_mode: Option<String>,
3462    #[serde(rename = "VolumeDriver")]
3463    #[serde(skip_serializing_if = "Option::is_none")]
3464    /// VolumeDriver is presently unused and is retained for Docker
3465    /// compatibility.
3466    pub volume_driver: Option<String>,
3467    #[serde(rename = "VolumesFrom")]
3468    #[serde(skip_serializing_if = "Option::is_none")]
3469    /// VolumesFrom is a list of containers which this container uses volumes
3470    /// from. This is not handled directly within libpod and is stored in an
3471    /// annotation.
3472    /// It is formatted as an array of container names and IDs.
3473    pub volumes_from: Option<Vec<String>>,
3474}
3475
3476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3477/// InspectContainerState provides a detailed record of a container's current
3478/// state. It is returned as part of InspectContainerData.
3479/// As with InspectContainerData, many portions of this struct are matched to
3480/// Docker, but here we see more fields that are unused (nonsensical in the
3481/// context of Libpod).
3482pub 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    /// CgroupPermissions is the permissions of the mounted device.
3555    /// Presently not populated.
3556    /// TODO.
3557    pub cgroup_permissions: Option<String>,
3558    #[serde(rename = "PathInContainer")]
3559    #[serde(skip_serializing_if = "Option::is_none")]
3560    /// PathInContainer is the path of the device within the container.
3561    pub path_in_container: Option<String>,
3562    #[serde(rename = "PathOnHost")]
3563    #[serde(skip_serializing_if = "Option::is_none")]
3564    /// PathOnHost is the path of the device on the host.
3565    pub path_on_host: Option<String>,
3566}
3567
3568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3569/// InspectExecProcess contains information about the process in a given exec
3570/// session.
3571pub struct InspectExecProcess {
3572    #[serde(skip_serializing_if = "Option::is_none")]
3573    /// Arguments are the arguments to the entrypoint command of the exec
3574    /// session.
3575    pub arguments: Option<Vec<String>>,
3576    #[serde(skip_serializing_if = "Option::is_none")]
3577    /// Entrypoint is the entrypoint for the exec session (the command that
3578    /// will be executed in the container).
3579    pub entrypoint: Option<String>,
3580    #[serde(skip_serializing_if = "Option::is_none")]
3581    /// Privileged is whether the exec session will be started with elevated
3582    /// privileges.
3583    pub privileged: Option<bool>,
3584    #[serde(skip_serializing_if = "Option::is_none")]
3585    /// Tty is whether the exec session created a terminal.
3586    pub tty: Option<bool>,
3587    #[serde(skip_serializing_if = "Option::is_none")]
3588    /// User is the user the exec session was started as.
3589    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    /// CanRemove is legacy and used purely for compatibility reasons.
3597    /// Will always be set to true, unless the exec session is running.
3598    pub can_remove: Option<bool>,
3599    #[serde(rename = "ContainerID")]
3600    #[serde(skip_serializing_if = "Option::is_none")]
3601    /// ContainerID is the ID of the container this exec session is attached
3602    /// to.
3603    pub container_id: Option<String>,
3604    #[serde(rename = "DetachKeys")]
3605    #[serde(skip_serializing_if = "Option::is_none")]
3606    /// DetachKeys are the detach keys used by the exec session.
3607    /// If set to "" the default keys are being used.
3608    /// Will show "<none>" if no detach keys are set.
3609    pub detach_keys: Option<String>,
3610    #[serde(rename = "ExitCode")]
3611    #[serde(skip_serializing_if = "Option::is_none")]
3612    /// ExitCode is the exit code of the exec session. Will be set to 0 if
3613    /// the exec session has not yet exited.
3614    pub exit_code: Option<i64>,
3615    #[serde(rename = "ID")]
3616    #[serde(skip_serializing_if = "Option::is_none")]
3617    /// ID is the ID of the exec session.
3618    pub id: Option<String>,
3619    #[serde(rename = "OpenStderr")]
3620    #[serde(skip_serializing_if = "Option::is_none")]
3621    /// OpenStderr is whether the container's STDERR stream will be attached.
3622    /// Always set to true if the exec session created a TTY.
3623    pub open_stderr: Option<bool>,
3624    #[serde(rename = "OpenStdin")]
3625    #[serde(skip_serializing_if = "Option::is_none")]
3626    /// OpenStdin is whether the container's STDIN stream will be attached
3627    /// to.
3628    pub open_stdin: Option<bool>,
3629    #[serde(rename = "OpenStdout")]
3630    #[serde(skip_serializing_if = "Option::is_none")]
3631    /// OpenStdout is whether the container's STDOUT stream will be attached.
3632    /// Always set to true if the exec session created a TTY.
3633    pub open_stdout: Option<bool>,
3634    #[serde(rename = "Pid")]
3635    #[serde(skip_serializing_if = "Option::is_none")]
3636    /// Pid is the PID of the exec session's process.
3637    /// Will be set to 0 if the exec session is not running.
3638    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    /// Running is whether the exec session is running.
3644    pub running: Option<bool>,
3645}
3646
3647#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3648/// InspectHostPort provides information on a port on the host that a container's
3649/// port is bound to.
3650pub struct InspectHostPort {
3651    #[serde(rename = "HostIp")]
3652    #[serde(skip_serializing_if = "Option::is_none")]
3653    /// IP on the host we are bound to. "" if not specified (binding to all
3654    /// IPs).
3655    pub host_ip: Option<String>,
3656    #[serde(rename = "HostPort")]
3657    #[serde(skip_serializing_if = "Option::is_none")]
3658    /// Port on the host we are bound to. No special formatting - just an
3659    /// integer stuffed into a string.
3660    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)]
3674/// InspectLogConfig holds information about a container's configured log driver
3675pub 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    /// Path specifies a path to the log file
3682    pub path: Option<String>,
3683    #[serde(rename = "Size")]
3684    #[serde(skip_serializing_if = "Option::is_none")]
3685    /// Size specifies a maximum size of the container log
3686    pub size: Option<String>,
3687    #[serde(rename = "Tag")]
3688    #[serde(skip_serializing_if = "Option::is_none")]
3689    /// Tag specifies a custom log tag for the container
3690    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)]
3697/// InspectMount provides a record of a single mount in a container. It contains
3698/// fields for both named and normal volumes. Only user-specified volumes will be
3699/// included, and tmpfs volumes are not included even if the user specified them.
3700pub struct InspectMount {
3701    #[serde(rename = "Destination")]
3702    #[serde(skip_serializing_if = "Option::is_none")]
3703    /// The destination directory for the volume. Specified as a path within
3704    /// the container, as it would be passed into the OCI runtime.
3705    pub destination: Option<String>,
3706    #[serde(rename = "Driver")]
3707    #[serde(skip_serializing_if = "Option::is_none")]
3708    /// The driver used for the named volume. Empty for bind mounts.
3709    pub driver: Option<String>,
3710    #[serde(rename = "Mode")]
3711    #[serde(skip_serializing_if = "Option::is_none")]
3712    /// Contains SELinux :z/:Z mount options. Unclear what, if anything, else
3713    /// goes in here.
3714    pub mode: Option<String>,
3715    #[serde(rename = "Name")]
3716    #[serde(skip_serializing_if = "Option::is_none")]
3717    /// The name of the volume. Empty for bind mounts.
3718    pub name: Option<String>,
3719    #[serde(rename = "Options")]
3720    #[serde(skip_serializing_if = "Option::is_none")]
3721    /// All remaining mount options. Additional data, not present in the
3722    /// original output.
3723    pub options: Option<Vec<String>>,
3724    #[serde(rename = "Propagation")]
3725    #[serde(skip_serializing_if = "Option::is_none")]
3726    /// Mount propagation for the mount. Can be empty if not specified, but
3727    /// is always printed - no omitempty.
3728    pub propagation: Option<String>,
3729    #[serde(rename = "RW")]
3730    #[serde(skip_serializing_if = "Option::is_none")]
3731    /// Whether the volume is read-write
3732    pub rw: Option<bool>,
3733    #[serde(rename = "Source")]
3734    #[serde(skip_serializing_if = "Option::is_none")]
3735    /// The source directory for the volume.
3736    pub source: Option<String>,
3737    #[serde(rename = "Type")]
3738    #[serde(skip_serializing_if = "Option::is_none")]
3739    /// Whether the mount is a volume or bind mount. Allowed values are
3740    /// "volume" and "bind".
3741    pub type_: Option<String>,
3742}
3743
3744#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3745/// InspectNetworkSettings holds information about the network settings of the
3746/// container.
3747/// Many fields are maintained only for compatibility with `docker inspect` and
3748/// are unused within Libpod.
3749pub struct InspectNetworkSettings {
3750    #[serde(rename = "AdditionalMACAddresses")]
3751    #[serde(skip_serializing_if = "Option::is_none")]
3752    /// AdditionalMacAddresses is a set of additional MAC Addresses beyond
3753    /// the first. CNI may configure more than one interface for a single
3754    /// network, which can cause this.
3755    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    /// EndpointID is unused, maintained exclusively for compatibility.
3762    pub endpoint_id: Option<String>,
3763    #[serde(rename = "Gateway")]
3764    #[serde(skip_serializing_if = "Option::is_none")]
3765    /// Gateway is the IP address of the gateway this network will use.
3766    pub gateway: Option<String>,
3767    #[serde(rename = "GlobalIPv6Address")]
3768    #[serde(skip_serializing_if = "Option::is_none")]
3769    /// GlobalIPv6Address is the global-scope IPv6 Address for this network.
3770    pub global_i_pv_6_address: Option<String>,
3771    #[serde(rename = "GlobalIPv6PrefixLen")]
3772    #[serde(skip_serializing_if = "Option::is_none")]
3773    /// GlobalIPv6PrefixLen is the length of the subnet mask of this network.
3774    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    /// IPAddress is the IP address for this network.
3781    pub ip_address: Option<String>,
3782    #[serde(rename = "IPPrefixLen")]
3783    #[serde(skip_serializing_if = "Option::is_none")]
3784    /// IPPrefixLen is the length of the subnet mask of this network.
3785    pub ip_prefix_len: Option<i64>,
3786    #[serde(rename = "IPv6Gateway")]
3787    #[serde(skip_serializing_if = "Option::is_none")]
3788    /// IPv6Gateway is the IPv6 gateway this network will use.
3789    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    /// MacAddress is the MAC address for the interface in this network.
3799    pub mac_address: Option<String>,
3800    #[serde(rename = "Networks")]
3801    #[serde(skip_serializing_if = "Option::is_none")]
3802    /// Networks contains information on non-default networks this
3803    /// container has joined.
3804    /// It is a map of network name to network information.
3805    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    /// SecondaryIPAddresses is a list of extra IP Addresses that the
3818    /// container has been assigned in this network.
3819    pub secondary_ip_addresses: Option<Vec<Address>>,
3820    #[serde(rename = "SecondaryIPv6Addresses")]
3821    #[serde(skip_serializing_if = "Option::is_none")]
3822    /// SecondaryIPv6Addresses is a list of extra IPv6 Addresses that the
3823    /// container has been assigned in this network.
3824    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    /// ID is the ID of the container.
3832    pub id: Option<String>,
3833    #[serde(rename = "Name")]
3834    #[serde(skip_serializing_if = "Option::is_none")]
3835    /// Name is the name of the container.
3836    pub name: Option<String>,
3837    #[serde(rename = "State")]
3838    #[serde(skip_serializing_if = "Option::is_none")]
3839    /// State is the current status of the container.
3840    pub state: Option<String>,
3841}
3842
3843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3844/// InspectPodData contains detailed information on a pod's configuration and
3845/// state. It is used as the output of Inspect on pods.
3846pub struct InspectPodData {
3847    #[serde(rename = "CgroupParent")]
3848    #[serde(skip_serializing_if = "Option::is_none")]
3849    /// CgroupParent is the parent of the pod's Cgroup.
3850    pub cgroup_parent: Option<String>,
3851    #[serde(rename = "CgroupPath")]
3852    #[serde(skip_serializing_if = "Option::is_none")]
3853    /// CgroupPath is the path to the pod's Cgroup.
3854    pub cgroup_path: Option<String>,
3855    #[serde(rename = "Containers")]
3856    #[serde(skip_serializing_if = "Option::is_none")]
3857    /// Containers gives a brief summary of all containers in the pod and
3858    /// their current status.
3859    pub containers: Option<Vec<InspectPodContainerInfo>>,
3860    #[serde(rename = "CreateCgroup")]
3861    #[serde(skip_serializing_if = "Option::is_none")]
3862    /// CreateCgroup is whether this pod will create its own Cgroup to group
3863    /// containers under.
3864    pub create_cgroup: Option<bool>,
3865    #[serde(rename = "CreateCommand")]
3866    #[serde(skip_serializing_if = "Option::is_none")]
3867    /// CreateCommand is the full command plus arguments of the process the
3868    /// container has been created with.
3869    pub create_command: Option<Vec<String>>,
3870    #[serde(rename = "CreateInfra")]
3871    #[serde(skip_serializing_if = "Option::is_none")]
3872    /// CreateInfra is whether this pod will create an infra container to
3873    /// share namespaces.
3874    pub create_infra: Option<bool>,
3875    #[serde(rename = "Created")]
3876    #[serde(skip_serializing_if = "Option::is_none")]
3877    /// Created is the time when the pod was created.
3878    pub created: Option<DateTime<Utc>>,
3879    #[serde(rename = "ExitPolicy")]
3880    #[serde(skip_serializing_if = "Option::is_none")]
3881    /// ExitPolicy of the pod.
3882    pub exit_policy: Option<String>,
3883    #[serde(rename = "Hostname")]
3884    #[serde(skip_serializing_if = "Option::is_none")]
3885    /// Hostname is the hostname that the pod will set.
3886    pub hostname: Option<String>,
3887    #[serde(rename = "Id")]
3888    #[serde(skip_serializing_if = "Option::is_none")]
3889    /// ID is the ID of the pod.
3890    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    /// InfraContainerID is the ID of the pod's infra container, if one is
3896    /// present.
3897    pub infra_container_id: Option<String>,
3898    #[serde(rename = "Labels")]
3899    #[serde(skip_serializing_if = "Option::is_none")]
3900    /// Labels is a set of key-value labels that have been applied to the
3901    /// pod.
3902    pub labels: Option<HashMap<String, String>>,
3903    #[serde(rename = "Name")]
3904    #[serde(skip_serializing_if = "Option::is_none")]
3905    /// Name is the name of the pod.
3906    pub name: Option<String>,
3907    #[serde(rename = "Namespace")]
3908    #[serde(skip_serializing_if = "Option::is_none")]
3909    /// Namespace is the Libpod namespace the pod is placed in.
3910    pub namespace: Option<String>,
3911    #[serde(rename = "NumContainers")]
3912    #[serde(skip_serializing_if = "Option::is_none")]
3913    /// NumContainers is the number of containers in the pod, including the
3914    /// infra container.
3915    pub num_containers: Option<u64>,
3916    #[serde(rename = "SharedNamespaces")]
3917    #[serde(skip_serializing_if = "Option::is_none")]
3918    /// SharedNamespaces contains a list of namespaces that will be shared by
3919    /// containers within the pod. Can only be set if CreateInfra is true.
3920    pub shared_namespaces: Option<Vec<String>>,
3921    #[serde(rename = "State")]
3922    #[serde(skip_serializing_if = "Option::is_none")]
3923    /// State represents the current state of the pod.
3924    pub state: Option<String>,
3925    #[serde(skip_serializing_if = "Option::is_none")]
3926    /// BlkioWeight contains the blkio weight limit for the pod
3927    pub blkio_weight: Option<u64>,
3928    #[serde(skip_serializing_if = "Option::is_none")]
3929    /// BlkioWeightDevice contains the blkio weight device limits for the pod
3930    pub blkio_weight_device: Option<Vec<InspectBlkioWeightDevice>>,
3931    #[serde(skip_serializing_if = "Option::is_none")]
3932    /// CPUPeriod contains the CPU period of the pod
3933    pub cpu_period: Option<u64>,
3934    #[serde(skip_serializing_if = "Option::is_none")]
3935    /// CPUQuota contains the CPU quota of the pod
3936    pub cpu_quota: Option<i64>,
3937    #[serde(skip_serializing_if = "Option::is_none")]
3938    /// CPUShares contains the cpu shares for the pod
3939    pub cpu_shares: Option<u64>,
3940    #[serde(skip_serializing_if = "Option::is_none")]
3941    /// CPUSetCPUs contains linux specific CPU data for the pod
3942    pub cpuset_cpus: Option<String>,
3943    #[serde(skip_serializing_if = "Option::is_none")]
3944    /// CPUSetMems contains linux specific CPU data for the pod
3945    pub cpuset_mems: Option<String>,
3946    #[serde(skip_serializing_if = "Option::is_none")]
3947    /// BlkioDeviceReadBps contains the Read/Access limit for the pod's devices
3948    pub device_read_bps: Option<Vec<InspectBlkioThrottleDevice>>,
3949    #[serde(skip_serializing_if = "Option::is_none")]
3950    /// BlkioDeviceReadBps contains the Read/Access limit for the pod's devices
3951    pub device_write_bps: Option<Vec<InspectBlkioThrottleDevice>>,
3952    #[serde(skip_serializing_if = "Option::is_none")]
3953    /// Devices contains the specified host devices
3954    pub devices: Option<Vec<InspectDevice>>,
3955    #[serde(skip_serializing_if = "Option::is_none")]
3956    /// MemoryLimit contains the specified cgroup memory limit for the pod
3957    pub memory_limit: Option<u64>,
3958    #[serde(skip_serializing_if = "Option::is_none")]
3959    /// MemorySwap contains the specified memory swap limit for the pod
3960    pub memory_swap: Option<u64>,
3961    #[serde(skip_serializing_if = "Option::is_none")]
3962    /// Mounts contains volume related information for the pod
3963    pub mounts: Option<Vec<InspectMount>>,
3964    #[serde(skip_serializing_if = "Option::is_none")]
3965    /// SecurityOpt contains the specified security labels and related SELinux information
3966    pub security_opt: Option<Vec<String>>,
3967    #[serde(skip_serializing_if = "Option::is_none")]
3968    /// VolumesFrom contains the containers that the pod inherits mounts from
3969    pub volumes_from: Option<Vec<String>>,
3970}
3971
3972#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3973/// InspectPodInfraConfig contains the configuration of the pod's infra
3974/// container.
3975pub struct InspectPodInfraConfig {
3976    #[serde(rename = "DNSOption")]
3977    #[serde(skip_serializing_if = "Option::is_none")]
3978    /// DNSOption is a set of DNS options that will be used by the infra
3979    /// container's resolv.conf and shared with the remainder of the pod.
3980    pub dns_option: Option<Vec<String>>,
3981    #[serde(rename = "DNSSearch")]
3982    #[serde(skip_serializing_if = "Option::is_none")]
3983    /// DNSSearch is a set of DNS search domains that will be used by the
3984    /// infra container's resolv.conf and shared with the remainder of the
3985    /// pod.
3986    pub dns_search: Option<Vec<String>>,
3987    #[serde(rename = "DNSServer")]
3988    #[serde(skip_serializing_if = "Option::is_none")]
3989    /// DNSServer is a set of DNS Servers that will be used by the infra
3990    /// container's resolv.conf and shared with the remainder of the pod.
3991    pub dns_server: Option<Vec<String>>,
3992    #[serde(rename = "HostAdd")]
3993    #[serde(skip_serializing_if = "Option::is_none")]
3994    /// HostAdd adds a number of hosts to the infra container's resolv.conf
3995    /// which will be shared with the rest of the pod.
3996    pub host_add: Option<Vec<String>>,
3997    #[serde(rename = "HostNetwork")]
3998    #[serde(skip_serializing_if = "Option::is_none")]
3999    /// HostNetwork is whether the infra container (and thus the whole pod)
4000    /// will use the host's network and not create a network namespace.
4001    pub host_network: Option<bool>,
4002    #[serde(rename = "NetworkOptions")]
4003    #[serde(skip_serializing_if = "Option::is_none")]
4004    /// NetworkOptions are additional options for each network
4005    pub network_options: Option<HashMap<String, Vec<String>>>,
4006    #[serde(rename = "Networks")]
4007    #[serde(skip_serializing_if = "Option::is_none")]
4008    /// Networks is a list of networks the pod will join.
4009    pub networks: Option<Vec<String>>,
4010    #[serde(rename = "NoManageHosts")]
4011    #[serde(skip_serializing_if = "Option::is_none")]
4012    /// NoManageHosts indicates that the pod will not manage /etc/hosts and
4013    /// instead each container will handle their own.
4014    pub no_manage_hosts: Option<bool>,
4015    #[serde(rename = "NoManageResolvConf")]
4016    #[serde(skip_serializing_if = "Option::is_none")]
4017    /// NoManageResolvConf indicates that the pod will not manage resolv.conf
4018    /// and instead each container will handle their own.
4019    pub no_manage_resolv_conf: Option<bool>,
4020    #[serde(rename = "PortBindings")]
4021    #[serde(skip_serializing_if = "Option::is_none")]
4022    /// PortBindings are ports that will be forwarded to the infra container
4023    /// and then shared with the pod.
4024    pub port_bindings: Option<HashMap<String, Option<Vec<InspectHostPort>>>>,
4025    #[serde(rename = "StaticIP")]
4026    #[serde(skip_serializing_if = "Option::is_none")]
4027    /// StaticIP is a static IPv4 that will be assigned to the infra
4028    /// container and then used by the pod.
4029    pub static_ip: Option<String>,
4030    #[serde(rename = "StaticMAC")]
4031    #[serde(skip_serializing_if = "Option::is_none")]
4032    /// StaticMAC is a static MAC address that will be assigned to the infra
4033    /// container and then used by the pod.
4034    pub static_mac: Option<String>,
4035    #[serde(skip_serializing_if = "Option::is_none")]
4036    /// CPUPeriod contains the CPU period of the pod
4037    pub cpu_period: Option<u64>,
4038    #[serde(skip_serializing_if = "Option::is_none")]
4039    /// CPUQuota contains the CPU quota of the pod
4040    pub cpu_quota: Option<i64>,
4041    #[serde(skip_serializing_if = "Option::is_none")]
4042    /// CPUSetCPUs contains linux specific CPU data for the container
4043    pub cpuset_cpus: Option<String>,
4044    #[serde(skip_serializing_if = "Option::is_none")]
4045    /// Pid is the PID namespace mode of the pod's infra container
4046    pub pid_ns: Option<String>,
4047    #[serde(skip_serializing_if = "Option::is_none")]
4048    /// UserNS is the usernamespace that all the containers in the pod will join.
4049    pub userns: Option<String>,
4050    #[serde(skip_serializing_if = "Option::is_none")]
4051    /// UtsNS is the uts namespace that all containers in the pod will join
4052    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    /// MaximumRetryCount is the maximum number of retries allowed if the
4060    /// "on-failure" restart policy is in use. Not used if "on-failure" is
4061    /// not set.
4062    pub maximum_retry_count: Option<u64>,
4063    #[serde(rename = "Name")]
4064    #[serde(skip_serializing_if = "Option::is_none")]
4065    /// Name contains the container's restart policy.
4066    /// Allowable values are "no" or "" (take no action),
4067    /// "on-failure" (restart on non-zero exit code, with an optional max
4068    /// retry count), and "always" (always restart on container stop, unless
4069    /// explicitly requested by API).
4070    /// Note that this is NOT actually a name of any sort - the poor naming
4071    /// is for Docker compatibility.
4072    pub name: Option<String>,
4073}
4074
4075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4076/// InspectSecret contains information on secrets mounted inside the container
4077pub struct InspectSecret {
4078    #[serde(rename = "GID")]
4079    #[serde(skip_serializing_if = "Option::is_none")]
4080    /// ID is the GID of the mounted secret file
4081    pub gid: Option<u32>,
4082    #[serde(rename = "ID")]
4083    #[serde(skip_serializing_if = "Option::is_none")]
4084    /// ID is the ID of the secret
4085    pub id: Option<String>,
4086    #[serde(rename = "Mode")]
4087    #[serde(skip_serializing_if = "Option::is_none")]
4088    /// ID is the ID of the mode of the mounted secret file
4089    pub mode: Option<u32>,
4090    #[serde(rename = "Name")]
4091    #[serde(skip_serializing_if = "Option::is_none")]
4092    /// Name is the name of the secret
4093    pub name: Option<String>,
4094    #[serde(rename = "UID")]
4095    #[serde(skip_serializing_if = "Option::is_none")]
4096    /// ID is the UID of the mounted secret file
4097    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    /// Hard is the hard limit that will be applied.
4105    pub hard: Option<i64>,
4106    #[serde(rename = "Name")]
4107    #[serde(skip_serializing_if = "Option::is_none")]
4108    /// Name is the name (type) of the ulimit.
4109    pub name: Option<String>,
4110    #[serde(rename = "Soft")]
4111    #[serde(skip_serializing_if = "Option::is_none")]
4112    /// Soft is the soft limit that will be applied.
4113    pub soft: Option<i64>,
4114}
4115
4116pub type IpcMode = String;
4117
4118/// Isolation represents the isolation technology of a container. The supported
4119/// values are platform specific
4120pub type Isolation = String;
4121
4122/// Kubernetes YAML file successfully deployed to cluster
4123pub 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    /// EndIP last IP in the subnet which should be used to assign ips.
4131    pub end_ip: Option<String>,
4132    #[serde(skip_serializing_if = "Option::is_none")]
4133    /// StartIP first IP in the subnet which should be used to assign ips.
4134    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    /// Error which occurred during Rm operation (if any).
4142    /// This field is optional and may be omitted if no error occurred.
4143    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    /// Podman extensions
4175    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    /// Error contains text of errors from c/image
4203    pub error: Option<String>,
4204    #[serde(skip_serializing_if = "Option::is_none")]
4205    /// ID contains image id (retained for backwards compatibility)
4206    pub id: Option<String>,
4207    #[serde(skip_serializing_if = "Option::is_none")]
4208    /// Images contains the ID's of the images pulled
4209    pub images: Option<Vec<String>>,
4210    #[serde(skip_serializing_if = "Option::is_none")]
4211    /// Stream used to provide output from c/image
4212    pub stream: Option<String>,
4213}
4214
4215#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4216/// LibpodImagesRemoveReport is the return type for image removal via the rest
4217/// api.
4218pub struct LibpodImagesRemoveReport {
4219    #[serde(rename = "Deleted")]
4220    #[serde(skip_serializing_if = "Option::is_none")]
4221    /// Deleted images.
4222    pub deleted: Option<Vec<String>>,
4223    #[serde(rename = "Errors")]
4224    #[serde(skip_serializing_if = "Option::is_none")]
4225    /// Image removal requires is to return data and an error.
4226    pub errors: Option<Vec<String>>,
4227    #[serde(rename = "ExitCode")]
4228    #[serde(skip_serializing_if = "Option::is_none")]
4229    /// ExitCode describes the exit codes as described in the `podman rmi`
4230    /// man page.
4231    pub exit_code: Option<i64>,
4232    #[serde(rename = "Untagged")]
4233    #[serde(skip_serializing_if = "Option::is_none")]
4234    /// Untagged images. Can be longer than Deleted.
4235    pub untagged: Option<Vec<String>>,
4236}
4237
4238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4239/// LinuxBlockIO for Linux cgroup 'blkio' resource management
4240pub struct LinuxBlockIo {
4241    #[serde(rename = "leafWeight")]
4242    #[serde(skip_serializing_if = "Option::is_none")]
4243    /// Specifies tasks' weight in the given cgroup while competing with the cgroup's child cgroups, CFQ scheduler only
4244    pub leaf_weight: Option<u16>,
4245    #[serde(rename = "throttleReadBpsDevice")]
4246    #[serde(skip_serializing_if = "Option::is_none")]
4247    /// IO read rate limit per cgroup per device, bytes per second
4248    pub throttle_read_bps_device: Option<Vec<LinuxThrottleDevice>>,
4249    #[serde(rename = "throttleReadIOPSDevice")]
4250    #[serde(skip_serializing_if = "Option::is_none")]
4251    /// IO read rate limit per cgroup per device, IO per second
4252    pub throttle_read_iops_device: Option<Vec<LinuxThrottleDevice>>,
4253    #[serde(rename = "throttleWriteBpsDevice")]
4254    #[serde(skip_serializing_if = "Option::is_none")]
4255    /// IO write rate limit per cgroup per device, bytes per second
4256    pub throttle_write_bps_device: Option<Vec<LinuxThrottleDevice>>,
4257    #[serde(rename = "throttleWriteIOPSDevice")]
4258    #[serde(skip_serializing_if = "Option::is_none")]
4259    /// IO write rate limit per cgroup per device, IO per second
4260    pub throttle_write_iops_device: Option<Vec<LinuxThrottleDevice>>,
4261    #[serde(skip_serializing_if = "Option::is_none")]
4262    /// Specifies per cgroup weight
4263    pub weight: Option<u16>,
4264    #[serde(rename = "weightDevice")]
4265    #[serde(skip_serializing_if = "Option::is_none")]
4266    /// Weight per cgroup per device, can override BlkioWeight
4267    pub weight_device: Option<Vec<LinuxWeightDevice>>,
4268}
4269
4270#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4271/// LinuxBlockIODevice holds major:minor format supported in blkio cgroup
4272pub struct LinuxBlockIoDevice {
4273    #[serde(skip_serializing_if = "Option::is_none")]
4274    /// Major is the device's major number.
4275    pub major: Option<i64>,
4276    #[serde(skip_serializing_if = "Option::is_none")]
4277    /// Minor is the device's minor number.
4278    pub minor: Option<i64>,
4279}
4280
4281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4282/// LinuxCPU for Linux cgroup 'cpu' resource management
4283pub struct LinuxCpu {
4284    #[serde(skip_serializing_if = "Option::is_none")]
4285    /// CPU hardcap burst limit (in usecs). Allowed accumulated cpu time additionally for burst in a
4286    /// given period.
4287    pub burst: Option<u64>,
4288    #[serde(skip_serializing_if = "Option::is_none")]
4289    /// CPUs to use within the cpuset. Default is to use any CPU available.
4290    pub cpus: Option<String>,
4291    #[serde(skip_serializing_if = "Option::is_none")]
4292    /// cgroups are configured with minimum weight, 0: default behavior, 1: SCHED_IDLE.
4293    pub idle: Option<i64>,
4294    #[serde(skip_serializing_if = "Option::is_none")]
4295    /// List of memory nodes in the cpuset. Default is to use any available memory node.
4296    pub mems: Option<String>,
4297    #[serde(skip_serializing_if = "Option::is_none")]
4298    /// CPU period to be used for hardcapping (in usecs).
4299    pub period: Option<u64>,
4300    #[serde(skip_serializing_if = "Option::is_none")]
4301    /// CPU hardcap limit (in usecs). Allowed cpu time in a given period.
4302    pub quota: Option<i64>,
4303    #[serde(rename = "realtimePeriod")]
4304    #[serde(skip_serializing_if = "Option::is_none")]
4305    /// CPU period to be used for realtime scheduling (in usecs).
4306    pub realtime_period: Option<u64>,
4307    #[serde(rename = "realtimeRuntime")]
4308    #[serde(skip_serializing_if = "Option::is_none")]
4309    /// How much time realtime scheduling may use (in usecs).
4310    pub realtime_runtime: Option<i64>,
4311    #[serde(skip_serializing_if = "Option::is_none")]
4312    /// CPU shares (relative weight (ratio) vs. other cgroups with cpu shares).
4313    pub shares: Option<u64>,
4314}
4315
4316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4317/// LinuxDevice represents the mknod information for a Linux special device file
4318pub struct LinuxDevice {
4319    #[serde(rename = "fileMode")]
4320    pub file_mode: Option<u32>,
4321    #[serde(skip_serializing_if = "Option::is_none")]
4322    /// Gid of the device.
4323    pub gid: Option<u32>,
4324    #[serde(skip_serializing_if = "Option::is_none")]
4325    /// Major is the device's major number.
4326    pub major: Option<i64>,
4327    #[serde(skip_serializing_if = "Option::is_none")]
4328    /// Minor is the device's minor number.
4329    pub minor: Option<i64>,
4330    #[serde(skip_serializing_if = "Option::is_none")]
4331    /// Path to the device.
4332    pub path: Option<String>,
4333    #[serde(rename = "type")]
4334    #[serde(skip_serializing_if = "Option::is_none")]
4335    /// Device type, block, char, etc.
4336    pub type_: Option<String>,
4337    #[serde(skip_serializing_if = "Option::is_none")]
4338    /// UID of the device.
4339    pub uid: Option<u32>,
4340}
4341
4342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4343/// LinuxDeviceCgroup represents a device rule for the devices specified to
4344/// the device controller
4345pub struct LinuxDeviceCgroup {
4346    #[serde(skip_serializing_if = "Option::is_none")]
4347    /// Cgroup access permissions format, rwm.
4348    pub access: Option<String>,
4349    #[serde(skip_serializing_if = "Option::is_none")]
4350    /// Allow or deny
4351    pub allow: Option<bool>,
4352    #[serde(skip_serializing_if = "Option::is_none")]
4353    /// Major is the device's major number.
4354    pub major: Option<i64>,
4355    #[serde(skip_serializing_if = "Option::is_none")]
4356    /// Minor is the device's minor number.
4357    pub minor: Option<i64>,
4358    #[serde(rename = "type")]
4359    #[serde(skip_serializing_if = "Option::is_none")]
4360    /// Device type, block, char, etc.
4361    pub type_: Option<String>,
4362}
4363
4364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4365/// LinuxHugepageLimit structure corresponds to limiting kernel hugepages
4366pub struct LinuxHugepageLimit {
4367    #[serde(skip_serializing_if = "Option::is_none")]
4368    /// Limit is the limit of "hugepagesize" hugetlb usage
4369    pub limit: Option<u64>,
4370    #[serde(rename = "pageSize")]
4371    #[serde(skip_serializing_if = "Option::is_none")]
4372    /// Pagesize is the hugepage size
4373    /// Format: "<size><unit-prefix>B' (e.g. 64KB, 2MB, 1GB, etc.)
4374    pub page_size: Option<String>,
4375}
4376
4377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4378/// LinuxIDMapping specifies UID/GID mappings
4379pub struct LinuxIdMapping {
4380    #[serde(rename = "containerID")]
4381    #[serde(skip_serializing_if = "Option::is_none")]
4382    /// ContainerID is the starting UID/GID in the container
4383    pub container_id: Option<u32>,
4384    #[serde(rename = "hostID")]
4385    #[serde(skip_serializing_if = "Option::is_none")]
4386    /// HostID is the starting UID/GID on the host to be mapped to 'ContainerID'
4387    pub host_id: Option<u32>,
4388    #[serde(skip_serializing_if = "Option::is_none")]
4389    /// Size is the number of IDs to be mapped
4390    pub size: Option<u32>,
4391}
4392
4393#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4394/// LinuxInterfacePriority for network interfaces
4395pub struct LinuxInterfacePriority {
4396    #[serde(skip_serializing_if = "Option::is_none")]
4397    /// Name is the name of the network interface
4398    pub name: Option<String>,
4399    #[serde(skip_serializing_if = "Option::is_none")]
4400    /// Priority for the interface
4401    pub priority: Option<u32>,
4402}
4403
4404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4405/// LinuxMemory for Linux cgroup 'memory' resource management
4406pub struct LinuxMemory {
4407    #[serde(rename = "checkBeforeUpdate")]
4408    #[serde(skip_serializing_if = "Option::is_none")]
4409    /// CheckBeforeUpdate enables checking if a new memory limit is lower
4410    /// than the current usage during update, and if so, rejecting the new
4411    /// limit.
4412    pub check_before_update: Option<bool>,
4413    #[serde(rename = "disableOOMKiller")]
4414    #[serde(skip_serializing_if = "Option::is_none")]
4415    /// DisableOOMKiller disables the OOM killer for out of memory conditions
4416    pub disable_oom_killer: Option<bool>,
4417    #[serde(skip_serializing_if = "Option::is_none")]
4418    /// Kernel memory limit (in bytes).
4419    pub kernel: Option<i64>,
4420    #[serde(rename = "kernelTCP")]
4421    #[serde(skip_serializing_if = "Option::is_none")]
4422    /// Kernel memory limit for tcp (in bytes)
4423    pub kernel_tcp: Option<i64>,
4424    #[serde(skip_serializing_if = "Option::is_none")]
4425    /// Memory limit (in bytes).
4426    pub limit: Option<i64>,
4427    #[serde(skip_serializing_if = "Option::is_none")]
4428    /// Memory reservation or soft_limit (in bytes).
4429    pub reservation: Option<i64>,
4430    #[serde(skip_serializing_if = "Option::is_none")]
4431    /// Total memory limit (memory + swap).
4432    pub swap: Option<i64>,
4433    #[serde(skip_serializing_if = "Option::is_none")]
4434    /// How aggressive the kernel will swap memory pages.
4435    pub swappiness: Option<u64>,
4436    #[serde(rename = "useHierarchy")]
4437    #[serde(skip_serializing_if = "Option::is_none")]
4438    /// Enables hierarchical memory accounting
4439    pub use_hierarchy: Option<bool>,
4440}
4441
4442#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4443/// LinuxNetwork identification and priority configuration
4444pub struct LinuxNetwork {
4445    #[serde(rename = "classID")]
4446    #[serde(skip_serializing_if = "Option::is_none")]
4447    /// Set class identifier for container's network packets
4448    pub class_id: Option<u32>,
4449    #[serde(skip_serializing_if = "Option::is_none")]
4450    /// Set priority of network traffic for container
4451    pub priorities: Option<Vec<LinuxInterfacePriority>>,
4452}
4453
4454#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4455/// LinuxPersonality represents the Linux personality syscall input
4456pub struct LinuxPersonality {
4457    pub domain: Option<String>,
4458    #[serde(skip_serializing_if = "Option::is_none")]
4459    /// Additional flags
4460    pub flags: Option<Vec<String>>,
4461}
4462
4463pub type LinuxPersonalityDomain = String;
4464
4465pub type LinuxPersonalityFlag = String;
4466
4467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4468/// LinuxPids for Linux cgroup 'pids' resource management (Linux 4.3)
4469pub struct LinuxPids {
4470    #[serde(skip_serializing_if = "Option::is_none")]
4471    /// Maximum number of PIDs. Default is "no limit".
4472    pub limit: Option<i64>,
4473}
4474
4475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4476/// LinuxRdma for Linux cgroup 'rdma' resource management (Linux 4.11)
4477pub struct LinuxRdma {
4478    #[serde(rename = "hcaHandles")]
4479    #[serde(skip_serializing_if = "Option::is_none")]
4480    /// Maximum number of HCA handles that can be opened. Default is "no limit".
4481    pub hca_handles: Option<u32>,
4482    #[serde(rename = "hcaObjects")]
4483    #[serde(skip_serializing_if = "Option::is_none")]
4484    /// Maximum number of HCA objects that can be created. Default is "no limit".
4485    pub hca_objects: Option<u32>,
4486}
4487
4488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4489/// LinuxResources has container runtime resource constraints
4490pub 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    /// Devices configures the device allowlist.
4496    pub devices: Option<Vec<LinuxDeviceCgroup>>,
4497    #[serde(rename = "hugepageLimits")]
4498    #[serde(skip_serializing_if = "Option::is_none")]
4499    /// Hugetlb limit (in bytes)
4500    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    /// Rdma resource restriction configuration.
4506    /// Limits are a set of key value pairs that define RDMA resource limits,
4507    /// where the key is device name and value is resource limits.
4508    pub rdma: Option<HashMap<String, LinuxRdma>>,
4509    #[serde(skip_serializing_if = "Option::is_none")]
4510    /// Unified resources.
4511    pub unified: Option<HashMap<String, String>>,
4512}
4513
4514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4515/// LinuxThrottleDevice struct holds a `major:minor rate_per_second` pair
4516pub struct LinuxThrottleDevice {
4517    #[serde(skip_serializing_if = "Option::is_none")]
4518    /// Major is the device's major number.
4519    pub major: Option<i64>,
4520    #[serde(skip_serializing_if = "Option::is_none")]
4521    /// Minor is the device's minor number.
4522    pub minor: Option<i64>,
4523    #[serde(skip_serializing_if = "Option::is_none")]
4524    /// Rate is the IO rate limit per cgroup per device
4525    pub rate: Option<u64>,
4526}
4527
4528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4529/// LinuxWeightDevice struct holds a `major:minor weight` pair for weightDevice
4530pub struct LinuxWeightDevice {
4531    #[serde(rename = "leafWeight")]
4532    #[serde(skip_serializing_if = "Option::is_none")]
4533    /// LeafWeight is the bandwidth rate for the device while competing with the cgroup's child cgroups, CFQ scheduler only
4534    pub leaf_weight: Option<u16>,
4535    #[serde(skip_serializing_if = "Option::is_none")]
4536    /// Major is the device's major number.
4537    pub major: Option<i64>,
4538    #[serde(skip_serializing_if = "Option::is_none")]
4539    /// Minor is the device's minor number.
4540    pub minor: Option<i64>,
4541    #[serde(skip_serializing_if = "Option::is_none")]
4542    /// Weight is the bandwidth rate for the device.
4543    pub weight: Option<u16>,
4544}
4545
4546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4547/// ListContainer describes a container suitable for listing
4548pub struct ListContainer {
4549    #[serde(rename = "AutoRemove")]
4550    #[serde(skip_serializing_if = "Option::is_none")]
4551    /// AutoRemove
4552    pub auto_remove: Option<bool>,
4553    #[serde(rename = "Command")]
4554    #[serde(skip_serializing_if = "Option::is_none")]
4555    /// Container command
4556    pub command: Option<Vec<String>>,
4557    #[serde(rename = "Created")]
4558    #[serde(skip_serializing_if = "Option::is_none")]
4559    /// Container creation time
4560    pub created: Option<DateTime<Utc>>,
4561    #[serde(rename = "CreatedAt")]
4562    #[serde(skip_serializing_if = "Option::is_none")]
4563    /// Human-readable container creation time.
4564    pub created_at: Option<String>,
4565    #[serde(rename = "ExitCode")]
4566    #[serde(skip_serializing_if = "Option::is_none")]
4567    /// If container has exited, the return code from the command
4568    pub exit_code: Option<i32>,
4569    #[serde(rename = "Exited")]
4570    #[serde(skip_serializing_if = "Option::is_none")]
4571    /// If container has exited/stopped
4572    pub exited: Option<bool>,
4573    #[serde(rename = "ExitedAt")]
4574    #[serde(skip_serializing_if = "Option::is_none")]
4575    /// Time container exited
4576    pub exited_at: Option<i64>,
4577    #[serde(rename = "Id")]
4578    #[serde(skip_serializing_if = "Option::is_none")]
4579    /// The unique identifier for the container
4580    pub id: Option<String>,
4581    #[serde(rename = "Image")]
4582    #[serde(skip_serializing_if = "Option::is_none")]
4583    /// Container image
4584    pub image: Option<String>,
4585    #[serde(rename = "ImageID")]
4586    #[serde(skip_serializing_if = "Option::is_none")]
4587    /// Container image ID
4588    pub image_id: Option<String>,
4589    #[serde(rename = "IsInfra")]
4590    #[serde(skip_serializing_if = "Option::is_none")]
4591    /// If this container is a Pod infra container
4592    pub is_infra: Option<bool>,
4593    #[serde(rename = "Labels")]
4594    #[serde(skip_serializing_if = "Option::is_none")]
4595    /// Labels for container
4596    pub labels: Option<HashMap<String, String>>,
4597    #[serde(rename = "Mounts")]
4598    #[serde(skip_serializing_if = "Option::is_none")]
4599    /// User volume mounts
4600    pub mounts: Option<Vec<String>>,
4601    #[serde(rename = "Names")]
4602    #[serde(skip_serializing_if = "Option::is_none")]
4603    /// The names assigned to the container
4604    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    /// The network names assigned to the container
4610    pub networks: Option<Vec<String>>,
4611    #[serde(rename = "Pid")]
4612    #[serde(skip_serializing_if = "Option::is_none")]
4613    /// The process id of the container
4614    pub pid: Option<i64>,
4615    #[serde(rename = "Pod")]
4616    #[serde(skip_serializing_if = "Option::is_none")]
4617    /// If the container is part of Pod, the Pod ID. Requires the pod
4618    /// boolean to be set
4619    pub pod: Option<String>,
4620    #[serde(rename = "PodName")]
4621    #[serde(skip_serializing_if = "Option::is_none")]
4622    /// If the container is part of Pod, the Pod name. Requires the pod
4623    /// boolean to be set
4624    pub pod_name: Option<String>,
4625    #[serde(rename = "Ports")]
4626    #[serde(skip_serializing_if = "Option::is_none")]
4627    /// Port mappings
4628    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    /// Time when container started
4634    pub started_at: Option<i64>,
4635    #[serde(rename = "State")]
4636    #[serde(skip_serializing_if = "Option::is_none")]
4637    /// State of container
4638    pub state: Option<String>,
4639    #[serde(rename = "Status")]
4640    #[serde(skip_serializing_if = "Option::is_none")]
4641    /// Status is a human-readable approximation of a duration for json output
4642    pub status: Option<String>,
4643}
4644
4645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4646/// ListContainerNamespaces contains the identifiers of the container's Linux namespaces
4647pub struct ListContainerNamespaces {
4648    #[serde(rename = "Cgroup")]
4649    #[serde(skip_serializing_if = "Option::is_none")]
4650    /// Cgroup namespace
4651    pub cgroup: Option<String>,
4652    #[serde(rename = "Ipc")]
4653    #[serde(skip_serializing_if = "Option::is_none")]
4654    /// IPC namespace
4655    pub ipc: Option<String>,
4656    #[serde(rename = "Mnt")]
4657    #[serde(skip_serializing_if = "Option::is_none")]
4658    /// Mount namespace
4659    pub mnt: Option<String>,
4660    #[serde(rename = "Net")]
4661    #[serde(skip_serializing_if = "Option::is_none")]
4662    /// Network namespace
4663    pub net: Option<String>,
4664    #[serde(rename = "Pidns")]
4665    #[serde(skip_serializing_if = "Option::is_none")]
4666    /// PID namespace
4667    pub pidns: Option<String>,
4668    #[serde(rename = "User")]
4669    #[serde(skip_serializing_if = "Option::is_none")]
4670    /// User namespace
4671    pub user: Option<String>,
4672    #[serde(rename = "Uts")]
4673    #[serde(skip_serializing_if = "Option::is_none")]
4674    /// UTS namespace
4675    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    /// Network names connected to infra container
4720    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)]
4727/// Volume list response
4728pub struct ListResponse {
4729    #[serde(rename = "Volumes")]
4730    #[serde(skip_serializing_if = "Option::is_none")]
4731    /// List of volumes
4732    pub volumes: Option<Vec<Volume>>,
4733    #[serde(rename = "Warnings")]
4734    #[serde(skip_serializing_if = "Option::is_none")]
4735    /// Warnings that occurred when fetching the list of volumes.
4736    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)]
4750/// LogConfig describes the logging characteristics for a container
4751pub struct LogConfigLibpod {
4752    #[serde(skip_serializing_if = "Option::is_none")]
4753    /// LogDriver is the container's log driver.
4754    /// Optional.
4755    pub driver: Option<String>,
4756    #[serde(skip_serializing_if = "Option::is_none")]
4757    /// A set of options to accompany the log driver.
4758    /// Optional.
4759    pub options: Option<HashMap<String, String>>,
4760    #[serde(skip_serializing_if = "Option::is_none")]
4761    /// LogPath is the path the container's logs will be stored at.
4762    /// Only available if LogDriver is set to "json-file" or "k8s-file".
4763    /// Optional.
4764    pub path: Option<String>,
4765    #[serde(skip_serializing_if = "Option::is_none")]
4766    /// Size is the maximum size of the log file
4767    /// Optional.
4768    pub size: Option<i64>,
4769}
4770
4771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4772/// ManifestAddOptions provides model for adding digests to manifest list
4773pub struct ManifestAddOptions {
4774    #[serde(skip_serializing_if = "Option::is_none")]
4775    /// True when operating on a list to include all images
4776    pub all: Option<bool>,
4777    #[serde(skip_serializing_if = "Option::is_none")]
4778    /// Annotation to add to manifest list
4779    pub annotation: Option<Vec<String>>,
4780    #[serde(skip_serializing_if = "Option::is_none")]
4781    /// Annotations to add to manifest list by a map which is prefferred over Annotation
4782    pub annotations: Option<HashMap<String, String>>,
4783    #[serde(skip_serializing_if = "Option::is_none")]
4784    /// Arch overrides the architecture for the image
4785    pub arch: Option<String>,
4786    #[serde(skip_serializing_if = "Option::is_none")]
4787    /// Feature list for the image
4788    pub features: Option<Vec<String>>,
4789    #[serde(skip_serializing_if = "Option::is_none")]
4790    /// Images is an optional list of images to add to manifest list
4791    pub images: Option<Vec<String>>,
4792    #[serde(skip_serializing_if = "Option::is_none")]
4793    /// OS overrides the operating system for the image
4794    pub os: Option<String>,
4795    #[serde(skip_serializing_if = "Option::is_none")]
4796    /// OS features for the image
4797    pub os_features: Option<Vec<String>>,
4798    #[serde(skip_serializing_if = "Option::is_none")]
4799    /// OSVersion overrides the operating system for the image
4800    pub os_version: Option<String>,
4801    #[serde(skip_serializing_if = "Option::is_none")]
4802    /// Variant for the image
4803    pub variant: Option<String>,
4804}
4805
4806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4807/// ManifestAnnotateOptions provides model for annotating manifest list
4808pub struct ManifestAnnotateOptions {
4809    #[serde(skip_serializing_if = "Option::is_none")]
4810    /// Annotation to add to manifest list
4811    pub annotation: Option<Vec<String>>,
4812    #[serde(skip_serializing_if = "Option::is_none")]
4813    /// Annotations to add to manifest list by a map which is prefferred over Annotation
4814    pub annotations: Option<HashMap<String, String>>,
4815    #[serde(skip_serializing_if = "Option::is_none")]
4816    /// Arch overrides the architecture for the image
4817    pub arch: Option<String>,
4818    #[serde(skip_serializing_if = "Option::is_none")]
4819    /// Feature list for the image
4820    pub features: Option<Vec<String>>,
4821    #[serde(skip_serializing_if = "Option::is_none")]
4822    /// OS overrides the operating system for the image
4823    pub os: Option<String>,
4824    #[serde(skip_serializing_if = "Option::is_none")]
4825    /// OS features for the image
4826    pub os_features: Option<Vec<String>>,
4827    #[serde(skip_serializing_if = "Option::is_none")]
4828    /// OSVersion overrides the operating system for the image
4829    pub os_version: Option<String>,
4830    #[serde(skip_serializing_if = "Option::is_none")]
4831    /// Variant for the image
4832    pub variant: Option<String>,
4833}
4834
4835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4836/// swagger 2.0 does not support oneOf for schema validation.
4837///
4838/// Operation "update" uses all fields.
4839/// Operation "remove" uses fields: Operation and Images
4840/// Operation "annotate" uses fields: Operation and Annotations
4841pub struct ManifestModifyOptions {
4842    #[serde(skip_serializing_if = "Option::is_none")]
4843    /// True when operating on a list to include all images
4844    pub all: Option<bool>,
4845    #[serde(skip_serializing_if = "Option::is_none")]
4846    /// Annotation to add to manifest list
4847    pub annotation: Option<Vec<String>>,
4848    #[serde(skip_serializing_if = "Option::is_none")]
4849    /// Annotations to add to manifest list by a map which is prefferred over Annotation
4850    pub annotations: Option<HashMap<String, String>>,
4851    #[serde(skip_serializing_if = "Option::is_none")]
4852    /// Arch overrides the architecture for the image
4853    pub arch: Option<String>,
4854    #[serde(skip_serializing_if = "Option::is_none")]
4855    /// Feature list for the image
4856    pub features: Option<Vec<String>>,
4857    #[serde(skip_serializing_if = "Option::is_none")]
4858    /// Images is an optional list of images to add to manifest list
4859    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    /// OS overrides the operating system for the image
4864    pub os: Option<String>,
4865    #[serde(skip_serializing_if = "Option::is_none")]
4866    /// OS features for the image
4867    pub os_features: Option<Vec<String>>,
4868    #[serde(skip_serializing_if = "Option::is_none")]
4869    /// OSVersion overrides the operating system for the image
4870    pub os_version: Option<String>,
4871    #[serde(skip_serializing_if = "Option::is_none")]
4872    /// Variant for the image
4873    pub variant: Option<String>,
4874}
4875
4876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4877/// ManifestModifyReport provides the model for removed digests and changed manifest
4878pub struct ManifestModifyReport {
4879    #[serde(rename = "Id")]
4880    #[serde(skip_serializing_if = "Option::is_none")]
4881    /// Manifest List ID
4882    pub id: Option<String>,
4883    #[serde(skip_serializing_if = "Option::is_none")]
4884    /// Errors associated with operation
4885    pub errors: Option<Vec<String>>,
4886    #[serde(skip_serializing_if = "Option::is_none")]
4887    /// Images to removed from manifest list, otherwise not provided.
4888    pub images: Option<Vec<String>>,
4889}
4890
4891#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4892/// ManifestPushReport provides the model for the pushed manifest
4893pub struct ManifestPushReport {
4894    #[serde(rename = "Id")]
4895    #[serde(skip_serializing_if = "Option::is_none")]
4896    /// ID of the pushed manifest
4897    pub id: Option<String>,
4898    #[serde(skip_serializing_if = "Option::is_none")]
4899    /// Error contains text of errors from pushing
4900    pub error: Option<String>,
4901    #[serde(skip_serializing_if = "Option::is_none")]
4902    /// Stream used to provide push progress
4903    pub stream: Option<String>,
4904}
4905
4906/// ManifestRemoveOptions provides the model for removing digests from a manifest
4907pub type ManifestRemoveOptions = Value;
4908
4909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4910/// ManifestRemoveReport provides the model for the removed manifest
4911pub struct ManifestRemoveReport {
4912    #[serde(rename = "Deleted")]
4913    #[serde(skip_serializing_if = "Option::is_none")]
4914    /// Deleted manifest list.
4915    pub deleted: Option<Vec<String>>,
4916    #[serde(rename = "Errors")]
4917    #[serde(skip_serializing_if = "Option::is_none")]
4918    /// Errors associated with operation
4919    pub errors: Option<Vec<String>>,
4920    #[serde(rename = "ExitCode")]
4921    #[serde(skip_serializing_if = "Option::is_none")]
4922    /// ExitCode describes the exit codes as described in the `podman rmi`
4923    /// man page.
4924    pub exit_code: Option<i64>,
4925    #[serde(rename = "Untagged")]
4926    #[serde(skip_serializing_if = "Option::is_none")]
4927    /// Untagged images. Can be longer than Deleted.
4928    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    /// Source specifies the name of the mount. Depending on mount type, this
4957    /// may be a volume name or a host path, or even ignored.
4958    /// Source is not supported for tmpfs (must be an empty value)
4959    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)]
4972/// This is used for reporting the mountpoints in use by a container.
4973pub struct MountPoint {
4974    #[serde(rename = "Destination")]
4975    #[serde(skip_serializing_if = "Option::is_none")]
4976    /// Destination is the path relative to the container root (`/`) where the
4977    /// Source is mounted inside the container.
4978    pub destination: Option<String>,
4979    #[serde(rename = "Driver")]
4980    #[serde(skip_serializing_if = "Option::is_none")]
4981    /// Driver is the volume driver used to create the volume (if it is a volume).
4982    pub driver: Option<String>,
4983    #[serde(rename = "Mode")]
4984    #[serde(skip_serializing_if = "Option::is_none")]
4985    /// Mode is a comma separated list of options supplied by the user when
4986    /// creating the bind/volume mount.
4987    ///
4988    /// The default is platform-specific (`"z"` on Linux, empty on Windows).
4989    pub mode: Option<String>,
4990    #[serde(rename = "Name")]
4991    #[serde(skip_serializing_if = "Option::is_none")]
4992    /// Name is the name reference to the underlying data defined by `Source`
4993    /// e.g., the volume name.
4994    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    /// RW indicates whether the mount is mounted writable (read-write).
5000    pub rw: Option<bool>,
5001    #[serde(rename = "Source")]
5002    #[serde(skip_serializing_if = "Option::is_none")]
5003    /// Source is the source location of the mount.
5004    ///
5005    /// For volumes, this contains the storage location of the volume (within
5006    /// `/var/lib/docker/volumes/`). For bind-mounts, and `npipe`, this contains
5007    /// the source (host) part of the bind-mount. For `tmpfs` mount points, this
5008    /// field is empty.
5009    pub source: Option<String>,
5010    #[serde(rename = "Type")]
5011    pub type_: Option<String>,
5012}
5013
5014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5015/// NamedVolume holds information about a named volume that will be mounted into
5016/// the container.
5017pub struct NamedVolume {
5018    #[serde(rename = "Dest")]
5019    #[serde(skip_serializing_if = "Option::is_none")]
5020    /// Destination to mount the named volume within the container. Must be
5021    /// an absolute path. Path will be created if it does not exist.
5022    pub dest: Option<String>,
5023    #[serde(rename = "IsAnonymous")]
5024    #[serde(skip_serializing_if = "Option::is_none")]
5025    /// IsAnonymous sets the named volume as anonymous even if it has a name
5026    /// This is used for emptyDir volumes from a kube yaml
5027    pub is_anonymous: Option<bool>,
5028    #[serde(rename = "Name")]
5029    #[serde(skip_serializing_if = "Option::is_none")]
5030    /// Name is the name of the named volume to be mounted. May be empty.
5031    /// If empty, a new named volume with a pseudorandomly generated name
5032    /// will be mounted at the given destination.
5033    pub name: Option<String>,
5034    #[serde(rename = "Options")]
5035    #[serde(skip_serializing_if = "Option::is_none")]
5036    /// Options are options that the named volume will be mounted with.
5037    pub options: Option<Vec<String>>,
5038    #[serde(rename = "SubPath")]
5039    #[serde(skip_serializing_if = "Option::is_none")]
5040    /// SubPath stores the sub directory of the named volume to be mounted in the container
5041    pub sub_path: Option<String>,
5042}
5043
5044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5045/// Namespace describes the namespace
5046pub 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)]
5055/// NetOptions reflect the shared network options between
5056/// pods and containers
5057pub 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    /// NetworkOptions are additional options for each network
5071    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    /// Created contains the timestamp when this network was created.
5086    pub created: Option<DateTime<Utc>>,
5087    #[serde(skip_serializing_if = "Option::is_none")]
5088    /// DNSEnabled is whether name resolution is active for container on
5089    /// this Network. Only supported with the bridge driver.
5090    pub dns_enabled: Option<bool>,
5091    #[serde(skip_serializing_if = "Option::is_none")]
5092    /// Driver for this Network, e.g. bridge, macvlan...
5093    pub driver: Option<String>,
5094    #[serde(skip_serializing_if = "Option::is_none")]
5095    /// ID of the Network.
5096    pub id: Option<String>,
5097    #[serde(skip_serializing_if = "Option::is_none")]
5098    /// Internal is whether the Network should not have external routes
5099    /// to public or other Networks.
5100    pub internal: Option<bool>,
5101    #[serde(skip_serializing_if = "Option::is_none")]
5102    /// IPAMOptions contains options used for the ip assignment.
5103    pub ipam_options: Option<HashMap<String, String>>,
5104    #[serde(rename = "ipv6_enabled")]
5105    #[serde(skip_serializing_if = "Option::is_none")]
5106    /// IPv6Enabled if set to true an ipv6 subnet should be created for this net.
5107    pub ipv_6_enabled: Option<bool>,
5108    #[serde(skip_serializing_if = "Option::is_none")]
5109    /// Labels is a set of key-value labels that have been applied to the
5110    /// Network.
5111    pub labels: Option<HashMap<String, String>>,
5112    #[serde(skip_serializing_if = "Option::is_none")]
5113    /// Name of the Network.
5114    pub name: Option<String>,
5115    #[serde(skip_serializing_if = "Option::is_none")]
5116    /// List of custom DNS server for podman's DNS resolver at network level,
5117    /// all the containers attached to this network will consider resolvers
5118    /// configured at network level.
5119    pub network_dns_servers: Option<Vec<String>>,
5120    #[serde(skip_serializing_if = "Option::is_none")]
5121    /// NetworkInterface is the network interface name on the host.
5122    pub network_interface: Option<String>,
5123    #[serde(skip_serializing_if = "Option::is_none")]
5124    /// Options is a set of key-value options that have been applied to
5125    /// the Network.
5126    pub options: Option<HashMap<String, String>>,
5127    #[serde(skip_serializing_if = "Option::is_none")]
5128    /// Subnets to use for this network.
5129    pub subnets: Option<Vec<Subnet>>,
5130}
5131
5132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5133/// NetworkConnect represents the data to be used to connect a container to the network
5134pub 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)]
5143/// NetworkConnectOptions describes options for connecting
5144/// a container to a network
5145pub struct NetworkConnectOptions {
5146    #[serde(skip_serializing_if = "Option::is_none")]
5147    /// Aliases contains a list of names which the dns server should resolve
5148    /// to this container. Should only be set when DNSEnabled is true on the Network.
5149    /// If aliases are set but there is no dns support for this network the
5150    /// network interface implementation should ignore this and NOT error.
5151    /// Optional.
5152    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    /// InterfaceName for this container. Required in the backend.
5157    /// Optional in the frontend. Will be filled with ethX (where X is a integer) when empty.
5158    pub interface_name: Option<String>,
5159    #[serde(skip_serializing_if = "Option::is_none")]
5160    /// StaticIPs for this container. Optional.
5161    pub static_ips: Option<Vec<String>>,
5162    #[serde(skip_serializing_if = "Option::is_none")]
5163    /// StaticMac for this container. Optional.
5164    pub static_mac: Option<String>,
5165}
5166
5167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5168/// NetworkCreate is the expected body of the "create network" http request message
5169pub 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    /// Check for networks with duplicate names.
5176    /// Network is primarily keyed based on a random ID and not on the name.
5177    /// Network name is strictly a user-friendly alias to the network
5178    /// which is uniquely identified using ID.
5179    /// And there is no guaranteed way to check for duplicates.
5180    /// Option CheckDuplicate is there to provide a best effort checking of any networks
5181    /// which has the same name but it is not guaranteed to catch all name collisions.
5182    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)]
5214/// network created
5215pub 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    /// Check for networks with duplicate names.
5232    /// Network is primarily keyed based on a random ID and not on the name.
5233    /// Network name is strictly a user-friendly alias to the network
5234    /// which is uniquely identified using ID.
5235    /// And there is no guaranteed way to check for duplicates.
5236    /// Option CheckDuplicate is there to provide a best effort checking of any networks
5237    /// which has the same name but it is not guaranteed to catch all name collisions.
5238    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)]
5273/// NetworkDisconnect represents the data to be used to disconnect a container from the network
5274pub 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)]
5286/// OK
5287pub 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)]
5294/// NetworkPruneReport containers the name of network and an error
5295/// associated in its pruning (removal)
5296pub 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)]
5306/// NetworkResource is the body of the "get network" http response message
5307pub 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)]
5360/// NetworkRmReport describes the results of network removal
5361pub 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)]
5371/// NetworkSettings exposes the network settings in the api
5372pub 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)]
5429/// NetworkUpdateOptions describes options to update a network
5430pub 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)]
5438/// NetworkingConfig represents the container's networking configuration for each of its interfaces
5439/// Carries the networking configs specified in the `docker run` and `docker network connect` commands
5440pub 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)]
5447/// No such secret
5448pub struct NoSuchSecret {
5449    #[serde(skip_serializing_if = "Option::is_none")]
5450    /// API root cause formatted for automated parsing
5451    pub cause: Option<String>,
5452    #[serde(skip_serializing_if = "Option::is_none")]
5453    /// human error message, formatted for a human to read
5454    pub message: Option<String>,
5455    #[serde(skip_serializing_if = "Option::is_none")]
5456    /// HTTP response code
5457    pub response: Option<i64>,
5458}
5459
5460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5461/// OverlayVolume holds information about an overlay volume that will be mounted into
5462/// the container.
5463pub struct OverlayVolume {
5464    #[serde(skip_serializing_if = "Option::is_none")]
5465    /// Destination is the absolute path where the mount will be placed in the container.
5466    pub destination: Option<String>,
5467    #[serde(skip_serializing_if = "Option::is_none")]
5468    /// Options holds overlay volume options.
5469    pub options: Option<Vec<String>>,
5470    #[serde(skip_serializing_if = "Option::is_none")]
5471    /// Source specifies the source path of the mount.
5472    pub source: Option<String>,
5473}
5474
5475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5476/// POSIXRlimit type and restrictions
5477pub struct PosixRlimit {
5478    #[serde(skip_serializing_if = "Option::is_none")]
5479    /// Hard is the hard limit for the specified type
5480    pub hard: Option<u64>,
5481    #[serde(skip_serializing_if = "Option::is_none")]
5482    /// Soft is the soft limit for the specified type
5483    pub soft: Option<u64>,
5484    #[serde(rename = "type")]
5485    #[serde(skip_serializing_if = "Option::is_none")]
5486    /// Type of the rlimit to set
5487    pub type_: Option<String>,
5488}
5489
5490#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5491/// PeerInfo represents one peer of an overlay network
5492pub 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    /// Aliases contains a list of names which the dns server should resolve
5505    /// to this container. Should only be set when DNSEnabled is true on the Network.
5506    /// If aliases are set but there is no dns support for this network the
5507    /// network interface implementation should ignore this and NOT error.
5508    /// Optional.
5509    pub aliases: Option<Vec<String>>,
5510    #[serde(skip_serializing_if = "Option::is_none")]
5511    /// InterfaceName for this container. Required in the backend.
5512    /// Optional in the frontend. Will be filled with ethX (where X is a integer) when empty.
5513    pub interface_name: Option<String>,
5514    #[serde(skip_serializing_if = "Option::is_none")]
5515    /// StaticIPs for this container. Optional.
5516    pub static_ips: Option<Vec<String>>,
5517    #[serde(skip_serializing_if = "Option::is_none")]
5518    /// StaticMac for this container. Optional.
5519    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    /// Architecture field specifies the CPU architecture, for example
5528    /// `amd64` or `ppc64`.
5529    pub architecture: Option<String>,
5530    #[serde(skip_serializing_if = "Option::is_none")]
5531    /// OS specifies the operating system, for example `linux` or `windows`.
5532    pub os: Option<String>,
5533    #[serde(rename = "os.features")]
5534    #[serde(skip_serializing_if = "Option::is_none")]
5535    /// OSFeatures is an optional field specifying an array of strings,
5536    /// each listing a required OS feature (for example on Windows `win32k`).
5537    pub os_features: Option<Vec<String>>,
5538    #[serde(rename = "os.version")]
5539    #[serde(skip_serializing_if = "Option::is_none")]
5540    /// OSVersion is an optional field specifying the operating system
5541    /// version, for example on Windows `10.0.14393.1066`.
5542    pub os_version: Option<String>,
5543    #[serde(skip_serializing_if = "Option::is_none")]
5544    /// Variant is an optional field specifying a variant of the CPU, for
5545    /// example `v7` to specify ARMv7 when architecture is `arm`.
5546    pub variant: Option<String>,
5547}
5548
5549pub type PlayKubeLibpodRequestParam = String;
5550
5551#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5552/// PlayKubePod represents a single pod and associated containers created by play kube
5553pub struct PlayKubePod {
5554    #[serde(rename = "ContainerErrors")]
5555    #[serde(skip_serializing_if = "Option::is_none")]
5556    /// ContainerErrors - any errors that occurred while starting containers
5557    /// in the pod.
5558    pub container_errors: Option<Vec<String>>,
5559    #[serde(rename = "Containers")]
5560    #[serde(skip_serializing_if = "Option::is_none")]
5561    /// Containers - the IDs of the containers running in the created pod.
5562    pub containers: Option<Vec<String>>,
5563    #[serde(rename = "ID")]
5564    #[serde(skip_serializing_if = "Option::is_none")]
5565    /// ID - ID of the pod created as a result of play kube.
5566    pub id: Option<String>,
5567    #[serde(rename = "InitContainers")]
5568    #[serde(skip_serializing_if = "Option::is_none")]
5569    /// InitContainers - the IDs of the init containers to be run in the created pod.
5570    pub init_containers: Option<Vec<String>>,
5571    #[serde(rename = "Logs")]
5572    #[serde(skip_serializing_if = "Option::is_none")]
5573    /// Logs - non-fatal errors and log messages while processing.
5574    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    /// Pods - pods created by play kube.
5582    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    /// Secrets - secrets created by play kube
5592    pub secrets: Option<Vec<PlaySecret>>,
5593    #[serde(rename = "ServiceContainerID")]
5594    #[serde(skip_serializing_if = "Option::is_none")]
5595    /// ServiceContainerID - ID of the service container if one is created
5596    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    /// Volumes - volumes created by play kube.
5606    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    /// Name - Name of the volume created by play kube.
5614    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)]
5624/// Plugin A plugin for the Engine API
5625pub struct Plugin {
5626    #[serde(rename = "Config")]
5627    pub config: PluginConfig,
5628    #[serde(rename = "Enabled")]
5629    /// True if the plugin is running. False if the plugin is not running, only installed.
5630    pub enabled: bool,
5631    #[serde(rename = "Id")]
5632    #[serde(skip_serializing_if = "Option::is_none")]
5633    /// Id
5634    pub id: Option<String>,
5635    #[serde(rename = "Name")]
5636    /// name
5637    pub name: String,
5638    #[serde(rename = "PluginReference")]
5639    #[serde(skip_serializing_if = "Option::is_none")]
5640    /// plugin remote reference used to push/pull the plugin
5641    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    /// description
5652    pub description: String,
5653    #[serde(rename = "DockerVersion")]
5654    #[serde(skip_serializing_if = "Option::is_none")]
5655    /// Docker Version used to create the plugin
5656    pub docker_version: Option<String>,
5657    #[serde(rename = "Documentation")]
5658    /// documentation
5659    pub documentation: String,
5660    #[serde(rename = "Entrypoint")]
5661    #[serde(default)]
5662    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5663    /// entrypoint
5664    pub entrypoint: Vec<String>,
5665    #[serde(rename = "Env")]
5666    #[serde(default)]
5667    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5668    /// env
5669    pub env: Vec<PluginEnv>,
5670    #[serde(rename = "Interface")]
5671    pub interface: PluginConfigInterface,
5672    #[serde(rename = "IpcHost")]
5673    /// ipc host
5674    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    /// mounts
5681    pub mounts: Vec<PluginMount>,
5682    #[serde(rename = "Network")]
5683    pub network: PluginConfigNetwork,
5684    #[serde(rename = "PidHost")]
5685    /// pid host
5686    pub pid_host: bool,
5687    #[serde(rename = "PropagatedMount")]
5688    /// propagated mount
5689    pub propagated_mount: String,
5690    #[serde(rename = "User")]
5691    pub user: Option<PluginConfigUser>,
5692    #[serde(rename = "WorkDir")]
5693    /// work dir
5694    pub work_dir: String,
5695    pub rootfs: Option<PluginConfigRootfs>,
5696}
5697
5698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5699/// PluginConfigArgs plugin config args
5700pub struct PluginConfigArgs {
5701    #[serde(rename = "Description")]
5702    /// description
5703    pub description: String,
5704    #[serde(rename = "Name")]
5705    /// name
5706    pub name: String,
5707    #[serde(rename = "Settable")]
5708    #[serde(default)]
5709    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5710    /// settable
5711    pub settable: Vec<String>,
5712    #[serde(rename = "Value")]
5713    #[serde(default)]
5714    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5715    /// value
5716    pub value: Vec<String>,
5717}
5718
5719#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5720/// PluginConfigInterface The interface between Docker and the plugin
5721pub struct PluginConfigInterface {
5722    #[serde(rename = "ProtocolScheme")]
5723    #[serde(skip_serializing_if = "Option::is_none")]
5724    /// Protocol to use for clients connecting to the plugin.
5725    pub protocol_scheme: Option<String>,
5726    #[serde(rename = "Socket")]
5727    /// socket
5728    pub socket: String,
5729    #[serde(rename = "Types")]
5730    #[serde(default)]
5731    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5732    /// types
5733    pub types: Vec<PluginInterfaceType>,
5734}
5735
5736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5737/// PluginConfigLinux plugin config linux
5738pub struct PluginConfigLinux {
5739    #[serde(rename = "AllowAllDevices")]
5740    /// allow all devices
5741    pub allow_all_devices: bool,
5742    #[serde(rename = "Capabilities")]
5743    #[serde(default)]
5744    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5745    /// capabilities
5746    pub capabilities: Vec<String>,
5747    #[serde(rename = "Devices")]
5748    #[serde(default)]
5749    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5750    /// devices
5751    pub devices: Vec<PluginDevice>,
5752}
5753
5754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5755/// PluginConfigNetwork plugin config network
5756pub struct PluginConfigNetwork {
5757    #[serde(rename = "Type")]
5758    /// type
5759    pub type_: String,
5760}
5761
5762#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5763/// PluginConfigRootfs plugin config rootfs
5764pub struct PluginConfigRootfs {
5765    #[serde(skip_serializing_if = "Option::is_none")]
5766    /// diff ids
5767    pub diff_ids: Option<Vec<String>>,
5768    #[serde(rename = "type")]
5769    #[serde(skip_serializing_if = "Option::is_none")]
5770    /// type
5771    pub type_: Option<String>,
5772}
5773
5774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5775/// PluginConfigUser plugin config user
5776pub struct PluginConfigUser {
5777    #[serde(rename = "GID")]
5778    #[serde(skip_serializing_if = "Option::is_none")]
5779    /// g ID
5780    pub gid: Option<u32>,
5781    #[serde(rename = "UID")]
5782    #[serde(skip_serializing_if = "Option::is_none")]
5783    /// UID
5784    pub uid: Option<u32>,
5785}
5786
5787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5788/// PluginDevice plugin device
5789pub struct PluginDevice {
5790    #[serde(rename = "Description")]
5791    /// description
5792    pub description: String,
5793    #[serde(rename = "Name")]
5794    /// name
5795    pub name: String,
5796    #[serde(rename = "Path")]
5797    /// path
5798    pub path: String,
5799    #[serde(rename = "Settable")]
5800    #[serde(default)]
5801    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5802    /// settable
5803    pub settable: Vec<String>,
5804}
5805
5806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5807/// PluginEnv plugin env
5808pub struct PluginEnv {
5809    #[serde(rename = "Description")]
5810    /// description
5811    pub description: String,
5812    #[serde(rename = "Name")]
5813    /// name
5814    pub name: String,
5815    #[serde(rename = "Settable")]
5816    #[serde(default)]
5817    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5818    /// settable
5819    pub settable: Vec<String>,
5820    #[serde(rename = "Value")]
5821    /// value
5822    pub value: String,
5823}
5824
5825#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5826/// PluginInterfaceType plugin interface type
5827pub struct PluginInterfaceType {
5828    #[serde(rename = "Capability")]
5829    /// capability
5830    pub capability: String,
5831    #[serde(rename = "Prefix")]
5832    /// prefix
5833    pub prefix: String,
5834    #[serde(rename = "Version")]
5835    /// version
5836    pub version: String,
5837}
5838
5839#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5840/// PluginMount plugin mount
5841pub struct PluginMount {
5842    #[serde(rename = "Description")]
5843    /// description
5844    pub description: String,
5845    #[serde(rename = "Destination")]
5846    /// destination
5847    pub destination: String,
5848    #[serde(rename = "Name")]
5849    /// name
5850    pub name: String,
5851    #[serde(rename = "Options")]
5852    #[serde(default)]
5853    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5854    /// options
5855    pub options: Vec<String>,
5856    #[serde(rename = "Settable")]
5857    #[serde(default)]
5858    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5859    /// settable
5860    pub settable: Vec<String>,
5861    #[serde(rename = "Source")]
5862    /// source
5863    pub source: String,
5864    #[serde(rename = "Type")]
5865    /// type
5866    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    /// args
5875    pub args: Vec<String>,
5876    #[serde(rename = "Devices")]
5877    #[serde(default)]
5878    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5879    /// devices
5880    pub devices: Vec<PluginDevice>,
5881    #[serde(rename = "Env")]
5882    #[serde(default)]
5883    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5884    /// env
5885    pub env: Vec<String>,
5886    #[serde(rename = "Mounts")]
5887    #[serde(default)]
5888    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
5889    /// mounts
5890    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    /// ExitPolicy determines the pod's exit and stop behaviour.
5897    pub exit_policy: Option<String>,
5898    #[serde(skip_serializing_if = "Option::is_none")]
5899    /// Hostname is the pod's hostname. If not set, the name of the pod will
5900    /// be used (if a name was not provided here, the name auto-generated for
5901    /// the pod will be used). This will be used by the infra container and
5902    /// all containers in the pod as long as the UTS namespace is shared.
5903    /// Optional.
5904    pub hostname: Option<String>,
5905    #[serde(skip_serializing_if = "Option::is_none")]
5906    /// InfraCommand sets the command that will be used to start the infra
5907    /// container.
5908    /// If not set, the default set in the Libpod configuration file will be
5909    /// used.
5910    /// Conflicts with NoInfra=true.
5911    /// Optional.
5912    pub infra_command: Option<Vec<String>>,
5913    #[serde(skip_serializing_if = "Option::is_none")]
5914    /// InfraConmonPidFile is a custom path to store the infra container's
5915    /// conmon PID.
5916    pub infra_conmon_pid_file: Option<String>,
5917    #[serde(skip_serializing_if = "Option::is_none")]
5918    /// InfraImage is the image that will be used for the infra container.
5919    /// If not set, the default set in the Libpod configuration file will be
5920    /// used.
5921    /// Conflicts with NoInfra=true.
5922    /// Optional.
5923    pub infra_image: Option<String>,
5924    #[serde(skip_serializing_if = "Option::is_none")]
5925    /// InfraName is the name that will be used for the infra container.
5926    /// If not set, the default set in the Libpod configuration file will be
5927    /// used.
5928    /// Conflicts with NoInfra=true.
5929    /// Optional.
5930    pub infra_name: Option<String>,
5931    pub ipcns: Option<Namespace>,
5932    #[serde(skip_serializing_if = "Option::is_none")]
5933    /// Labels are key-value pairs that are used to add metadata to pods.
5934    /// Optional.
5935    pub labels: Option<HashMap<String, String>>,
5936    #[serde(skip_serializing_if = "Option::is_none")]
5937    /// Name is the name of the pod.
5938    /// If not provided, a name will be generated when the pod is created.
5939    /// Optional.
5940    pub name: Option<String>,
5941    #[serde(skip_serializing_if = "Option::is_none")]
5942    /// NoInfra tells the pod not to create an infra container. If this is
5943    /// done, many networking-related options will become unavailable.
5944    /// Conflicts with setting any options in PodNetworkConfig, and the
5945    /// InfraCommand and InfraImages in this struct.
5946    /// Optional.
5947    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    /// Devices contains user specified Devices to be added to the Pod
5953    pub pod_devices: Option<Vec<String>>,
5954    #[serde(skip_serializing_if = "Option::is_none")]
5955    /// PodCreateCommand is the command used to create this pod.
5956    /// This will be shown in the output of Inspect() on the pod, and may
5957    /// also be used by some tools that wish to recreate the pod
5958    /// (e.g. `podman generate systemd --new`).
5959    /// Optional.
5960    /// ShareParent determines if all containers in the pod will share the pod's cgroup as the cgroup parent
5961    pub share_parent: Option<bool>,
5962    #[serde(skip_serializing_if = "Option::is_none")]
5963    /// SharedNamespaces instructs the pod to share a set of namespaces.
5964    /// Shared namespaces will be joined (by default) by every container
5965    /// which joins the pod.
5966    /// If not set and NoInfra is false, the pod will set a default set of
5967    /// namespaces to share.
5968    /// Conflicts with NoInfra=true.
5969    /// Optional.
5970    pub shared_namespaces: Option<Vec<String>>,
5971    #[serde(skip_serializing_if = "Option::is_none")]
5972    /// Sysctl sets kernel parameters for the pod
5973    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)]
5979/// This will be expanded in future updates to pods.
5980pub struct PodCgroupConfig {
5981    #[serde(skip_serializing_if = "Option::is_none")]
5982    /// CgroupParent is the parent for the Cgroup that the pod will create.
5983    /// This pod cgroup will, in turn, be the default cgroup parent for all
5984    /// containers in the pod.
5985    /// Optional.
5986    pub cgroup_parent: Option<String>,
5987}
5988
5989/// status conflict
5990pub type PodCreateLibpod409Response = String;
5991
5992#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5993/// The JSON tags below are made to match the respective field in ContainerCreateOptions for the purpose of mapping.
5994pub 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    /// Map of networks names to ids the container should join to.
6059    /// You can request additional settings for each network, you can
6060    /// set network aliases, static ips, static mac address  and the
6061    /// network interface name for this container on the specific network.
6062    /// If the map is empty and the bridge network mode is set the container
6063    /// will be joined to the default network.
6064    pub networks: Option<HashMap<String, PerNetworkOptions>>,
6065    #[serde(skip_serializing_if = "Option::is_none")]
6066    /// CNINetworks is a list of CNI networks to join the container to.
6067    /// If this list is empty, the default CNI network will be joined
6068    /// instead. If at least one entry is present, we will not join the
6069    /// default network (unless it is part of this list).
6070    /// Only available if NetNS is set to bridge.
6071    /// Optional.
6072    /// Deprecated: as of podman 4.0 use "Networks" instead.
6073    pub cni_networks: Option<Vec<String>>,
6074    #[serde(skip_serializing_if = "Option::is_none")]
6075    /// DNSOption is a set of DNS options that will be used in the infra
6076    /// container's resolv.conf, which will, by default, be shared with all
6077    /// containers in the pod.
6078    /// Conflicts with NoInfra=true.
6079    /// Optional.
6080    pub dns_option: Option<Vec<String>>,
6081    #[serde(skip_serializing_if = "Option::is_none")]
6082    /// DNSSearch is a set of DNS search domains that will be used in the
6083    /// infra container's resolv.conf, which will, by default, be shared with
6084    /// all containers in the pod.
6085    /// If not provided, DNS search domains from the host's resolv.conf will
6086    /// be used.
6087    /// Conflicts with NoInfra=true.
6088    /// Optional.
6089    pub dns_search: Option<Vec<String>>,
6090    #[serde(skip_serializing_if = "Option::is_none")]
6091    /// DNSServer is a set of DNS servers that will be used in the infra
6092    /// container's resolv.conf, which will, by default, be shared with all
6093    /// containers in the pod.
6094    /// If not provided, the host's DNS servers will be used, unless the only
6095    /// server set is a localhost address. As the container cannot connect to
6096    /// the host's localhost, a default server will instead be set.
6097    /// Conflicts with NoInfra=true.
6098    /// Optional.
6099    pub dns_server: Option<Vec<String>>,
6100    #[serde(skip_serializing_if = "Option::is_none")]
6101    /// HostAdd is a set of hosts that will be added to the infra container's
6102    /// etc/hosts that will, by default, be shared with all containers in
6103    /// the pod.
6104    /// Conflicts with NoInfra=true and NoManageHosts.
6105    /// Optional.
6106    pub hostadd: Option<Vec<String>>,
6107    pub netns: Option<Namespace>,
6108    #[serde(skip_serializing_if = "Option::is_none")]
6109    /// NetworkOptions are additional options for each network
6110    /// Optional.
6111    pub network_options: Option<HashMap<String, Vec<String>>>,
6112    #[serde(skip_serializing_if = "Option::is_none")]
6113    /// NoManageHosts indicates that /etc/hosts should not be managed by the
6114    /// pod. Instead, each container will create a separate /etc/hosts as
6115    /// they would if not in a pod.
6116    /// Conflicts with HostAdd.
6117    pub no_manage_hosts: Option<bool>,
6118    #[serde(skip_serializing_if = "Option::is_none")]
6119    /// NoManageResolvConf indicates that /etc/resolv.conf should not be
6120    /// managed by the pod. Instead, each container will create and manage a
6121    /// separate resolv.conf as if they had not joined a pod.
6122    /// Conflicts with NoInfra=true and DNSServer, DNSSearch, DNSOption.
6123    /// Optional.
6124    pub no_manage_resolv_conf: Option<bool>,
6125    #[serde(skip_serializing_if = "Option::is_none")]
6126    /// PortMappings is a set of ports to map into the infra container.
6127    /// As, by default, containers share their network with the infra
6128    /// container, this will forward the ports to the entire pod.
6129    /// Only available if NetNS is set to Bridge, Slirp, or Pasta.
6130    /// Optional.
6131    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    /// CPU period of the cpuset, determined by --cpus
6158    pub cpu_period: Option<u64>,
6159    #[serde(skip_serializing_if = "Option::is_none")]
6160    /// CPU quota of the cpuset, determined by --cpus
6161    pub cpu_quota: Option<i64>,
6162    pub resource_limits: Option<LinuxResources>,
6163    #[serde(rename = "throttleReadBpsDevice")]
6164    #[serde(skip_serializing_if = "Option::is_none")]
6165    /// ThrottleReadBpsDevice contains the rate at which the devices in the pod can be read from/accessed
6166    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)]
6197/// PodSpecGenerator describes options to create a pod
6198pub struct PodSpecGenerator {
6199    #[serde(rename = "Networks")]
6200    #[serde(skip_serializing_if = "Option::is_none")]
6201    /// Map of networks names to ids the container should join to.
6202    /// You can request additional settings for each network, you can
6203    /// set network aliases, static ips, static mac address  and the
6204    /// network interface name for this container on the specific network.
6205    /// If the map is empty and the bridge network mode is set the container
6206    /// will be joined to the default network.
6207    pub networks: Option<HashMap<String, PerNetworkOptions>>,
6208    #[serde(skip_serializing_if = "Option::is_none")]
6209    /// CgroupParent is the parent for the Cgroup that the pod will create.
6210    /// This pod cgroup will, in turn, be the default cgroup parent for all
6211    /// containers in the pod.
6212    /// Optional.
6213    pub cgroup_parent: Option<String>,
6214    #[serde(skip_serializing_if = "Option::is_none")]
6215    /// CNINetworks is a list of CNI networks to join the container to.
6216    /// If this list is empty, the default CNI network will be joined
6217    /// instead. If at least one entry is present, we will not join the
6218    /// default network (unless it is part of this list).
6219    /// Only available if NetNS is set to bridge.
6220    /// Optional.
6221    /// Deprecated: as of podman 4.0 use "Networks" instead.
6222    pub cni_networks: Option<Vec<String>>,
6223    #[serde(skip_serializing_if = "Option::is_none")]
6224    /// CPU period of the cpuset, determined by --cpus
6225    pub cpu_period: Option<u64>,
6226    #[serde(skip_serializing_if = "Option::is_none")]
6227    /// CPU quota of the cpuset, determined by --cpus
6228    pub cpu_quota: Option<i64>,
6229    #[serde(skip_serializing_if = "Option::is_none")]
6230    /// DNSOption is a set of DNS options that will be used in the infra
6231    /// container's resolv.conf, which will, by default, be shared with all
6232    /// containers in the pod.
6233    /// Conflicts with NoInfra=true.
6234    /// Optional.
6235    pub dns_option: Option<Vec<String>>,
6236    #[serde(skip_serializing_if = "Option::is_none")]
6237    /// DNSSearch is a set of DNS search domains that will be used in the
6238    /// infra container's resolv.conf, which will, by default, be shared with
6239    /// all containers in the pod.
6240    /// If not provided, DNS search domains from the host's resolv.conf will
6241    /// be used.
6242    /// Conflicts with NoInfra=true.
6243    /// Optional.
6244    pub dns_search: Option<Vec<String>>,
6245    #[serde(skip_serializing_if = "Option::is_none")]
6246    /// DNSServer is a set of DNS servers that will be used in the infra
6247    /// container's resolv.conf, which will, by default, be shared with all
6248    /// containers in the pod.
6249    /// If not provided, the host's DNS servers will be used, unless the only
6250    /// server set is a localhost address. As the container cannot connect to
6251    /// the host's localhost, a default server will instead be set.
6252    /// Conflicts with NoInfra=true.
6253    /// Optional.
6254    pub dns_server: Option<Vec<String>>,
6255    #[serde(skip_serializing_if = "Option::is_none")]
6256    /// ExitPolicy determines the pod's exit and stop behaviour.
6257    pub exit_policy: Option<String>,
6258    #[serde(skip_serializing_if = "Option::is_none")]
6259    /// HostAdd is a set of hosts that will be added to the infra container's
6260    /// etc/hosts that will, by default, be shared with all containers in
6261    /// the pod.
6262    /// Conflicts with NoInfra=true and NoManageHosts.
6263    /// Optional.
6264    pub hostadd: Option<Vec<String>>,
6265    #[serde(skip_serializing_if = "Option::is_none")]
6266    /// Hostname is the pod's hostname. If not set, the name of the pod will
6267    /// be used (if a name was not provided here, the name auto-generated for
6268    /// the pod will be used). This will be used by the infra container and
6269    /// all containers in the pod as long as the UTS namespace is shared.
6270    /// Optional.
6271    pub hostname: Option<String>,
6272    pub idmappings: Option<IdMappingOptions>,
6273    #[serde(skip_serializing_if = "Option::is_none")]
6274    /// Image volumes bind-mount a container-image mount into the pod's infra container.
6275    /// Optional.
6276    pub image_volumes: Option<Vec<ImageVolume>>,
6277    #[serde(skip_serializing_if = "Option::is_none")]
6278    /// InfraCommand sets the command that will be used to start the infra
6279    /// container.
6280    /// If not set, the default set in the Libpod configuration file will be
6281    /// used.
6282    /// Conflicts with NoInfra=true.
6283    /// Optional.
6284    pub infra_command: Option<Vec<String>>,
6285    #[serde(skip_serializing_if = "Option::is_none")]
6286    /// InfraConmonPidFile is a custom path to store the infra container's
6287    /// conmon PID.
6288    pub infra_conmon_pid_file: Option<String>,
6289    #[serde(skip_serializing_if = "Option::is_none")]
6290    /// InfraImage is the image that will be used for the infra container.
6291    /// If not set, the default set in the Libpod configuration file will be
6292    /// used.
6293    /// Conflicts with NoInfra=true.
6294    /// Optional.
6295    pub infra_image: Option<String>,
6296    #[serde(skip_serializing_if = "Option::is_none")]
6297    /// InfraName is the name that will be used for the infra container.
6298    /// If not set, the default set in the Libpod configuration file will be
6299    /// used.
6300    /// Conflicts with NoInfra=true.
6301    /// Optional.
6302    pub infra_name: Option<String>,
6303    pub ipcns: Option<Namespace>,
6304    #[serde(skip_serializing_if = "Option::is_none")]
6305    /// Labels are key-value pairs that are used to add metadata to pods.
6306    /// Optional.
6307    pub labels: Option<HashMap<String, String>>,
6308    #[serde(skip_serializing_if = "Option::is_none")]
6309    /// Mounts are mounts that will be added to the pod.
6310    /// These will supersede Image Volumes and VolumesFrom volumes where
6311    /// there are conflicts.
6312    /// Optional.
6313    pub mounts: Option<Vec<Mount>>,
6314    #[serde(skip_serializing_if = "Option::is_none")]
6315    /// Name is the name of the pod.
6316    /// If not provided, a name will be generated when the pod is created.
6317    /// Optional.
6318    pub name: Option<String>,
6319    pub netns: Option<Namespace>,
6320    #[serde(skip_serializing_if = "Option::is_none")]
6321    /// NetworkOptions are additional options for each network
6322    /// Optional.
6323    pub network_options: Option<HashMap<String, Vec<String>>>,
6324    #[serde(skip_serializing_if = "Option::is_none")]
6325    /// NoInfra tells the pod not to create an infra container. If this is
6326    /// done, many networking-related options will become unavailable.
6327    /// Conflicts with setting any options in PodNetworkConfig, and the
6328    /// InfraCommand and InfraImages in this struct.
6329    /// Optional.
6330    pub no_infra: Option<bool>,
6331    #[serde(skip_serializing_if = "Option::is_none")]
6332    /// NoManageHosts indicates that /etc/hosts should not be managed by the
6333    /// pod. Instead, each container will create a separate /etc/hosts as
6334    /// they would if not in a pod.
6335    /// Conflicts with HostAdd.
6336    pub no_manage_hosts: Option<bool>,
6337    #[serde(skip_serializing_if = "Option::is_none")]
6338    /// NoManageResolvConf indicates that /etc/resolv.conf should not be
6339    /// managed by the pod. Instead, each container will create and manage a
6340    /// separate resolv.conf as if they had not joined a pod.
6341    /// Conflicts with NoInfra=true and DNSServer, DNSSearch, DNSOption.
6342    /// Optional.
6343    pub no_manage_resolv_conf: Option<bool>,
6344    #[serde(skip_serializing_if = "Option::is_none")]
6345    /// Overlay volumes are named volumes that will be added to the pod.
6346    /// Optional.
6347    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    /// Devices contains user specified Devices to be added to the Pod
6353    pub pod_devices: Option<Vec<String>>,
6354    #[serde(skip_serializing_if = "Option::is_none")]
6355    /// PortMappings is a set of ports to map into the infra container.
6356    /// As, by default, containers share their network with the infra
6357    /// container, this will forward the ports to the entire pod.
6358    /// Only available if NetNS is set to Bridge, Slirp, or Pasta.
6359    /// Optional.
6360    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    /// The ID of the pod's service container.
6367    pub service_container_id: Option<String>,
6368    #[serde(skip_serializing_if = "Option::is_none")]
6369    /// PodCreateCommand is the command used to create this pod.
6370    /// This will be shown in the output of Inspect() on the pod, and may
6371    /// also be used by some tools that wish to recreate the pod
6372    /// (e.g. `podman generate systemd --new`).
6373    /// Optional.
6374    /// ShareParent determines if all containers in the pod will share the pod's cgroup as the cgroup parent
6375    pub share_parent: Option<bool>,
6376    #[serde(skip_serializing_if = "Option::is_none")]
6377    /// SharedNamespaces instructs the pod to share a set of namespaces.
6378    /// Shared namespaces will be joined (by default) by every container
6379    /// which joins the pod.
6380    /// If not set and NoInfra is false, the pod will set a default set of
6381    /// namespaces to share.
6382    /// Conflicts with NoInfra=true.
6383    /// Optional.
6384    pub shared_namespaces: Option<Vec<String>>,
6385    #[serde(skip_serializing_if = "Option::is_none")]
6386    /// ShmSize is the size of the tmpfs to mount in at /dev/shm, in bytes.
6387    /// Conflicts with ShmSize if IpcNS is not private.
6388    /// Optional.
6389    pub shm_size: Option<i64>,
6390    #[serde(skip_serializing_if = "Option::is_none")]
6391    /// ShmSizeSystemd is the size of systemd-specific tmpfs mounts
6392    /// specifically /run, /run/lock, /var/log/journal and /tmp.
6393    /// Optional
6394    pub shm_size_systemd: Option<i64>,
6395    #[serde(skip_serializing_if = "Option::is_none")]
6396    /// Sysctl sets kernel parameters for the pod
6397    pub sysctl: Option<HashMap<String, String>>,
6398    #[serde(rename = "throttleReadBpsDevice")]
6399    #[serde(skip_serializing_if = "Option::is_none")]
6400    /// ThrottleReadBpsDevice contains the rate at which the devices in the pod can be read from/accessed
6401    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    /// Volumes are named volumes that will be added to the pod.
6406    /// These will supersede Image Volumes and VolumesFrom  volumes where
6407    /// there are conflicts.
6408    /// Optional.
6409    pub volumes: Option<Vec<NamedVolume>>,
6410    #[serde(skip_serializing_if = "Option::is_none")]
6411    /// VolumesFrom is a set of containers whose volumes will be added to
6412    /// this pod. The name or ID of the container must be provided, and
6413    /// may optionally be followed by a : and then one or more
6414    /// comma-separated options. Valid options are 'ro', 'rw', and 'z'.
6415    /// Options will be used for all volumes sourced from the container.
6416    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    /// Humanized disk usage read + write
6434    pub block_io: Option<String>,
6435    #[serde(rename = "CID")]
6436    #[serde(skip_serializing_if = "Option::is_none")]
6437    /// Container ID
6438    pub cid: Option<String>,
6439    #[serde(rename = "CPU")]
6440    #[serde(skip_serializing_if = "Option::is_none")]
6441    /// Percentage of CPU utilized by pod
6442    pub cpu: Option<String>,
6443    #[serde(rename = "Mem")]
6444    #[serde(skip_serializing_if = "Option::is_none")]
6445    /// Percentage of Memory utilized by pod
6446    pub mem: Option<String>,
6447    #[serde(rename = "MemUsage")]
6448    #[serde(skip_serializing_if = "Option::is_none")]
6449    /// Humanized Memory usage and maximum
6450    pub mem_usage: Option<String>,
6451    #[serde(rename = "MemUsageBytes")]
6452    #[serde(skip_serializing_if = "Option::is_none")]
6453    /// Memory usage and maximum in bytes
6454    pub mem_usage_bytes: Option<String>,
6455    #[serde(rename = "Name")]
6456    #[serde(skip_serializing_if = "Option::is_none")]
6457    /// Pod Name
6458    pub name: Option<String>,
6459    #[serde(rename = "NetIO")]
6460    #[serde(skip_serializing_if = "Option::is_none")]
6461    /// Network usage inbound + outbound
6462    pub net_io: Option<String>,
6463    #[serde(rename = "PIDS")]
6464    #[serde(skip_serializing_if = "Option::is_none")]
6465    /// Container PID
6466    pub pids: Option<String>,
6467    #[serde(rename = "Pod")]
6468    #[serde(skip_serializing_if = "Option::is_none")]
6469    /// Pod ID
6470    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    /// Image volumes bind-mount a container-image mount into the pod's infra container.
6487    /// Optional.
6488    pub image_volumes: Option<Vec<ImageVolume>>,
6489    #[serde(skip_serializing_if = "Option::is_none")]
6490    /// Mounts are mounts that will be added to the pod.
6491    /// These will supersede Image Volumes and VolumesFrom volumes where
6492    /// there are conflicts.
6493    /// Optional.
6494    pub mounts: Option<Vec<Mount>>,
6495    #[serde(skip_serializing_if = "Option::is_none")]
6496    /// Overlay volumes are named volumes that will be added to the pod.
6497    /// Optional.
6498    pub overlay_volumes: Option<Vec<OverlayVolume>>,
6499    #[serde(skip_serializing_if = "Option::is_none")]
6500    /// ShmSize is the size of the tmpfs to mount in at /dev/shm, in bytes.
6501    /// Conflicts with ShmSize if IpcNS is not private.
6502    /// Optional.
6503    pub shm_size: Option<i64>,
6504    #[serde(skip_serializing_if = "Option::is_none")]
6505    /// ShmSizeSystemd is the size of systemd-specific tmpfs mounts
6506    /// specifically /run, /run/lock, /var/log/journal and /tmp.
6507    /// Optional
6508    pub shm_size_systemd: Option<i64>,
6509    #[serde(skip_serializing_if = "Option::is_none")]
6510    /// Volumes are named volumes that will be added to the pod.
6511    /// These will supersede Image Volumes and VolumesFrom  volumes where
6512    /// there are conflicts.
6513    /// Optional.
6514    pub volumes: Option<Vec<NamedVolume>>,
6515    #[serde(skip_serializing_if = "Option::is_none")]
6516    /// VolumesFrom is a set of containers whose volumes will be added to
6517    /// this pod. The name or ID of the container must be provided, and
6518    /// may optionally be followed by a : and then one or more
6519    /// comma-separated options. Valid options are 'ro', 'rw', and 'z'.
6520    /// Options will be used for all volumes sourced from the container.
6521    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    /// Each process running in the container, where each is process
6530    /// is an array of values corresponding to the titles.
6531    pub processes: Vec<Vec<String>>,
6532    #[serde(rename = "Titles")]
6533    #[serde(default)]
6534    #[serde(deserialize_with = "deserialize_nonoptional_vec")]
6535    /// The ps column titles
6536    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)]
6550/// Port An open port on a container
6551pub struct Port {
6552    #[serde(rename = "IP")]
6553    #[serde(skip_serializing_if = "Option::is_none")]
6554    /// Host IP address that the container's port is mapped to
6555    pub ip: Option<String>,
6556    #[serde(rename = "PrivatePort")]
6557    /// Port on the container
6558    pub private_port: u16,
6559    #[serde(rename = "PublicPort")]
6560    #[serde(skip_serializing_if = "Option::is_none")]
6561    /// Port exposed on the host
6562    pub public_port: Option<u16>,
6563    #[serde(rename = "Type")]
6564    /// type
6565    pub type_: String,
6566}
6567
6568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6569/// PortBinding represents a binding between a Host IP address and a Host Port
6570pub struct PortBinding {
6571    #[serde(rename = "HostIp")]
6572    #[serde(skip_serializing_if = "Option::is_none")]
6573    /// HostIP is the host IP Address
6574    pub host_ip: Option<String>,
6575    #[serde(rename = "HostPort")]
6576    #[serde(skip_serializing_if = "Option::is_none")]
6577    /// HostPort is the host port number
6578    pub host_port: Option<String>,
6579}
6580
6581/// PortMap is a collection of PortBinding indexed by Port
6582pub 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    /// ContainerPort is the port number that will be exposed from the
6588    /// container.
6589    /// Mandatory.
6590    pub container_port: Option<u16>,
6591    #[serde(skip_serializing_if = "Option::is_none")]
6592    /// HostIP is the IP that we will bind to on the host.
6593    /// If unset, assumed to be 0.0.0.0 (all interfaces).
6594    pub host_ip: Option<String>,
6595    #[serde(skip_serializing_if = "Option::is_none")]
6596    /// HostPort is the port number that will be forwarded from the host into
6597    /// the container.
6598    /// If omitted, a random port on the host (guaranteed to be over 1024)
6599    /// will be assigned.
6600    pub host_port: Option<u16>,
6601    #[serde(skip_serializing_if = "Option::is_none")]
6602    /// Protocol is the protocol forward.
6603    /// Must be either "tcp", "udp", and "sctp", or some combination of these
6604    /// separated by commas.
6605    /// If unset, assumed to be TCP.
6606    pub protocol: Option<String>,
6607    #[serde(skip_serializing_if = "Option::is_none")]
6608    /// Range is the number of ports that will be forwarded, starting at
6609    /// HostPort and ContainerPort and counting up.
6610    /// This is 1-indexed, so 1 is assumed to be a single port (only the
6611    /// Hostport:Containerport mapping will be added), 2 is two ports (both
6612    /// Hostport:Containerport and Hostport+1:Containerport+1), etc.
6613    /// If unset, assumed to be 1 (a single port).
6614    /// Both hostport + range and containerport + range must be less than
6615    /// 65536.
6616    pub range: Option<u16>,
6617}
6618
6619/// PortSet is a collection of structs indexed by Port
6620pub 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
6637/// PublishState represents the state of a Volume as it pertains to its
6638/// use on a particular Node.
6639pub type PublishState = String;
6640
6641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6642/// PublishStatus represents the status of the volume as published to an
6643/// individual node
6644pub struct PublishStatus {
6645    #[serde(rename = "NodeID")]
6646    #[serde(skip_serializing_if = "Option::is_none")]
6647    /// NodeID is the ID of the swarm node this Volume is published to.
6648    pub node_id: Option<String>,
6649    #[serde(rename = "PublishContext")]
6650    #[serde(skip_serializing_if = "Option::is_none")]
6651    /// PublishContext is the PublishContext returned by the CSI plugin when
6652    /// a volume is published.
6653    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)]
6663/// Resources contains container's resources (cgroups config, ulimits...)
6664pub 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    /// Applicable to UNIX platforms
6686    pub cgroup_parent: Option<String>,
6687    #[serde(rename = "CpuCount")]
6688    #[serde(skip_serializing_if = "Option::is_none")]
6689    /// Applicable to Windows
6690    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    /// Applicable to all platforms
6709    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    /// KernelMemory specifies the kernel memory limit (in bytes) for the container.
6734    /// Deprecated: kernel 5.4 deprecated kmem.limit_in_bytes.
6735    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)]
6786/// Schema2HealthConfig is a HealthConfig, which holds configuration settings
6787/// for the HEALTHCHECK feature, from docker/docker/api/types/container.
6788pub struct Schema2HealthConfig {
6789    #[serde(rename = "Interval")]
6790    pub interval: Option<i64>,
6791    #[serde(rename = "Retries")]
6792    #[serde(skip_serializing_if = "Option::is_none")]
6793    /// Retries is the number of consecutive failures needed to consider a container as unhealthy.
6794    /// Zero means inherit.
6795    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    /// Test is the test to perform to check that the container is healthy.
6801    /// An empty slice means to inherit the default.
6802    /// The options are:
6803    /// {} : inherit healthcheck
6804    /// {"NONE"} : disable healthcheck
6805    /// {"CMD", args...} : exec arguments directly
6806    /// {"CMD-SHELL", command} : run command with system's default shell
6807    pub test: Option<Vec<String>>,
6808    #[serde(rename = "Timeout")]
6809    pub timeout: Option<i64>,
6810}
6811
6812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6813/// This is publicly visible as c/image/manifest.Schema2List.
6814/// Internal users should usually use Schema2List instead.
6815pub 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)]
6827/// This is publicly visible as c/image/manifest.Schema2ManifestDescriptor.
6828pub 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)]
6841/// Schema2PlatformSpec describes the platform which a particular manifest is
6842/// specialized for.
6843/// This is publicly visible as c/image/manifest.Schema2PlatformSpec.
6844pub 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
6861/// Scope defines the Scope of a Cluster Volume. This is how many nodes a
6862/// Volume can be accessed simultaneously on.
6863pub 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)]
6873/// Secret represents a Swarm Secret value that must be passed to the CSI
6874/// storage plugin when operating on this Volume. It represents one key-value
6875/// pair of possibly many.
6876pub struct Secret {
6877    #[serde(rename = "Key")]
6878    #[serde(skip_serializing_if = "Option::is_none")]
6879    /// Key is the name of the key of the key-value pair passed to the plugin.
6880    pub key: Option<String>,
6881    #[serde(rename = "Secret")]
6882    #[serde(skip_serializing_if = "Option::is_none")]
6883    /// Secret is the swarm Secret object from which to read data. This can be a
6884    /// Secret name or ID. The Secret data is retrieved by Swarm and used as the
6885    /// value of the key-value pair passed to the plugin.
6886    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    /// Base64-url-safe-encoded (RFC 4648) data to store as secret.
6894    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    /// Labels are labels on the secret
6900    pub labels: Option<HashMap<String, String>>,
6901    #[serde(rename = "Name")]
6902    #[serde(skip_serializing_if = "Option::is_none")]
6903    /// User-defined name of the secret.
6904    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)]
6917/// Secret create response
6918pub 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)]
6935/// Secret in use
6936pub struct SecretInUse {
6937    #[serde(skip_serializing_if = "Option::is_none")]
6938    /// API root cause formatted for automated parsing
6939    pub cause: Option<String>,
6940    #[serde(skip_serializing_if = "Option::is_none")]
6941    /// human error message, formatted for a human to read
6942    pub message: Option<String>,
6943    #[serde(skip_serializing_if = "Option::is_none")]
6944    /// HTTP response code
6945    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
6980/// Secret list response
6981pub type SecretListCompatResponse = Vec<SecretInfoReportCompat>;
6982
6983/// Secret list response
6984pub 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)]
7016/// ServiceInfo represents service parameters with the list of service's tasks
7017pub 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)]
7033/// ServiceUpdateResponse service update response
7034pub struct ServiceUpdateResponse {
7035    #[serde(rename = "Warnings")]
7036    #[serde(skip_serializing_if = "Option::is_none")]
7037    /// Optional warning messages
7038    pub warnings: Option<Vec<String>>,
7039}
7040
7041/// SharingMode defines the Sharing of a Cluster Volume. This is how Tasks using a
7042/// Volume at the same time can use it.
7043pub type SharingMode = String;
7044
7045/// It implements the os.Signal interface.
7046pub type Signal = i64;
7047
7048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7049/// SpecGenerator creates an OCI spec and Libpod configuration options to create
7050/// a container based on the given configuration.
7051pub struct SpecGenerator {
7052    #[serde(rename = "Networks")]
7053    #[serde(skip_serializing_if = "Option::is_none")]
7054    /// Map of networks names or ids that the container should join.
7055    /// You can request additional settings for each network, you can
7056    /// set network aliases, static ips, static mac address  and the
7057    /// network interface name for this container on the specific network.
7058    /// If the map is empty and the bridge network mode is set the container
7059    /// will be joined to the default network.
7060    pub networks: Option<HashMap<String, PerNetworkOptions>>,
7061    #[serde(skip_serializing_if = "Option::is_none")]
7062    /// Annotations are key-value options passed into the container runtime
7063    /// that can be used to trigger special behavior.
7064    /// Optional.
7065    pub annotations: Option<HashMap<String, String>>,
7066    #[serde(skip_serializing_if = "Option::is_none")]
7067    /// ApparmorProfile is the name of the Apparmor profile the container
7068    /// will use.
7069    /// Optional.
7070    pub apparmor_profile: Option<String>,
7071    #[serde(skip_serializing_if = "Option::is_none")]
7072    /// CapAdd are capabilities which will be added to the container.
7073    /// Conflicts with Privileged.
7074    /// Optional.
7075    pub cap_add: Option<Vec<String>>,
7076    #[serde(skip_serializing_if = "Option::is_none")]
7077    /// CapDrop are capabilities which will be removed from the container.
7078    /// Conflicts with Privileged.
7079    /// Optional.
7080    pub cap_drop: Option<Vec<String>>,
7081    #[serde(skip_serializing_if = "Option::is_none")]
7082    /// CgroupParent is the container's Cgroup parent.
7083    /// If not set, the default for the current cgroup driver will be used.
7084    /// Optional.
7085    pub cgroup_parent: Option<String>,
7086    pub cgroupns: Option<Namespace>,
7087    #[serde(skip_serializing_if = "Option::is_none")]
7088    /// CgroupsMode sets a policy for how cgroups will be created in the
7089    /// container, including the ability to disable creation entirely.
7090    pub cgroups_mode: Option<String>,
7091    #[serde(skip_serializing_if = "Option::is_none")]
7092    /// ChrootDirs is an additional set of directories that need to be
7093    /// treated as root directories. Standard bind mounts will be mounted
7094    /// into paths relative to these directories.
7095    pub chroot_directories: Option<Vec<String>>,
7096    #[serde(skip_serializing_if = "Option::is_none")]
7097    /// CNINetworks is a list of CNI networks to join the container to.
7098    /// If this list is empty, the default CNI network will be joined
7099    /// instead. If at least one entry is present, we will not join the
7100    /// default network (unless it is part of this list).
7101    /// Only available if NetNS is set to bridge.
7102    /// Optional.
7103    /// Deprecated: as of podman 4.0 use "Networks" instead.
7104    pub cni_networks: Option<Vec<String>>,
7105    #[serde(skip_serializing_if = "Option::is_none")]
7106    /// Command is the container's command.
7107    /// If not given and Image is specified, this will be populated by the
7108    /// image's configuration.
7109    /// Optional.
7110    pub command: Option<Vec<String>>,
7111    #[serde(skip_serializing_if = "Option::is_none")]
7112    /// ConmonPidFile is a path at which a PID file for Conmon will be
7113    /// placed.
7114    /// If not given, a default location will be used.
7115    /// Optional.
7116    pub conmon_pid_file: Option<String>,
7117    #[serde(rename = "containerCreateCommand")]
7118    #[serde(skip_serializing_if = "Option::is_none")]
7119    /// ContainerCreateCommand is the command that was used to create this
7120    /// container.
7121    /// This will be shown in the output of Inspect() on the container, and
7122    /// may also be used by some tools that wish to recreate the container
7123    /// (e.g. `podman generate systemd --new`).
7124    /// Optional.
7125    pub container_create_command: Option<Vec<String>>,
7126    #[serde(skip_serializing_if = "Option::is_none")]
7127    /// CPU period of the cpuset, determined by --cpus
7128    pub cpu_period: Option<u64>,
7129    #[serde(skip_serializing_if = "Option::is_none")]
7130    /// CPU quota of the cpuset, determined by --cpus
7131    pub cpu_quota: Option<i64>,
7132    #[serde(skip_serializing_if = "Option::is_none")]
7133    /// Create the working directory if it doesn't exist.
7134    /// If unset, it doesn't create it.
7135    /// Optional.
7136    pub create_working_dir: Option<bool>,
7137    #[serde(rename = "dependencyContainers")]
7138    #[serde(skip_serializing_if = "Option::is_none")]
7139    /// DependencyContainers is an array of containers this container
7140    /// depends on. Dependency containers must be started before this
7141    /// container. Dependencies can be specified by name or full/partial ID.
7142    /// Optional.
7143    pub dependency_containers: Option<Vec<String>>,
7144    #[serde(skip_serializing_if = "Option::is_none")]
7145    /// DeviceCgroupRule are device cgroup rules that allow containers
7146    /// to use additional types of devices.
7147    pub device_cgroup_rule: Option<Vec<LinuxDeviceCgroup>>,
7148    #[serde(skip_serializing_if = "Option::is_none")]
7149    /// Devices are devices that will be added to the container.
7150    /// Optional.
7151    pub devices: Option<Vec<LinuxDevice>>,
7152    #[serde(skip_serializing_if = "Option::is_none")]
7153    /// DevicesFrom is a way to ensure your container inherits device specific information from another container
7154    pub devices_from: Option<Vec<String>>,
7155    #[serde(skip_serializing_if = "Option::is_none")]
7156    /// DNSOptions is a set of DNS options that will be used in the
7157    /// container's resolv.conf, replacing the host's DNS options which are
7158    /// used by default.
7159    /// Conflicts with UseImageResolvConf.
7160    /// Optional.
7161    pub dns_option: Option<Vec<String>>,
7162    #[serde(skip_serializing_if = "Option::is_none")]
7163    /// DNSSearch is a set of DNS search domains that will be used in the
7164    /// container's resolv.conf, replacing the host's DNS search domains
7165    /// which are used by default.
7166    /// Conflicts with UseImageResolvConf.
7167    /// Optional.
7168    pub dns_search: Option<Vec<String>>,
7169    #[serde(skip_serializing_if = "Option::is_none")]
7170    /// DNSServers is a set of DNS servers that will be used in the
7171    /// container's resolv.conf, replacing the host's DNS Servers which are
7172    /// used by default.
7173    /// Conflicts with UseImageResolvConf.
7174    /// Optional.
7175    pub dns_server: Option<Vec<String>>,
7176    #[serde(skip_serializing_if = "Option::is_none")]
7177    /// Entrypoint is the container's entrypoint.
7178    /// If not given and Image is specified, this will be populated by the
7179    /// image's configuration.
7180    /// Optional.
7181    pub entrypoint: Option<Vec<String>>,
7182    #[serde(skip_serializing_if = "Option::is_none")]
7183    /// Env is a set of environment variables that will be set in the
7184    /// container.
7185    /// Optional.
7186    pub env: Option<HashMap<String, String>>,
7187    #[serde(skip_serializing_if = "Option::is_none")]
7188    /// EnvHost indicates that the host environment should be added to container
7189    /// Optional.
7190    pub env_host: Option<bool>,
7191    #[serde(skip_serializing_if = "Option::is_none")]
7192    /// EnvMerge takes the specified environment variables from image and preprocess them before injecting them into the
7193    /// container.
7194    pub envmerge: Option<Vec<String>>,
7195    #[serde(skip_serializing_if = "Option::is_none")]
7196    /// Expose is a number of ports that will be forwarded to the container
7197    /// if PublishExposedPorts is set.
7198    /// Expose is a map of uint16 (port number) to a string representing
7199    /// protocol i.e map[uint16]string. Allowed protocols are "tcp", "udp", and "sctp", or some
7200    /// combination of the three separated by commas.
7201    /// If protocol is set to "" we will assume TCP.
7202    /// Only available if NetNS is set to Bridge or Slirp, and
7203    /// PublishExposedPorts is set.
7204    /// Optional.
7205    pub expose: Option<Value>,
7206    #[serde(skip_serializing_if = "Option::is_none")]
7207    /// GroupEntry specifies arbitrary data to append to a file.
7208    pub group_entry: Option<String>,
7209    #[serde(skip_serializing_if = "Option::is_none")]
7210    /// Groups are a list of supplemental groups the container's user will
7211    /// be granted access to.
7212    /// Optional.
7213    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    /// HostDeviceList is used to recreate the mounted device on inherited containers
7218    pub host_device_list: Option<Vec<LinuxDevice>>,
7219    #[serde(skip_serializing_if = "Option::is_none")]
7220    /// HostAdd is a set of hosts which will be added to the container's
7221    /// etc/hosts file.
7222    /// Conflicts with UseImageHosts.
7223    /// Optional.
7224    pub hostadd: Option<Vec<String>>,
7225    #[serde(skip_serializing_if = "Option::is_none")]
7226    /// Hostname is the container's hostname. If not set, the hostname will
7227    /// not be modified (if UtsNS is not private) or will be set to the
7228    /// container ID (if UtsNS is private).
7229    /// Conflicts with UtsNS if UtsNS is not set to private.
7230    /// Optional.
7231    pub hostname: Option<String>,
7232    #[serde(skip_serializing_if = "Option::is_none")]
7233    /// HostUsers is a list of host usernames or UIDs to add to the container
7234    /// etc/passwd file
7235    pub hostusers: Option<Vec<String>>,
7236    #[serde(skip_serializing_if = "Option::is_none")]
7237    /// EnvHTTPProxy indicates that the http host proxy environment variables
7238    /// should be added to container
7239    /// Optional.
7240    pub httpproxy: Option<bool>,
7241    pub idmappings: Option<IdMappingOptions>,
7242    #[serde(skip_serializing_if = "Option::is_none")]
7243    /// Image is the image the container will be based on. The image will be
7244    /// used as the container's root filesystem, and its environment vars,
7245    /// volumes, and other configuration will be applied to the container.
7246    /// Conflicts with Rootfs.
7247    /// At least one of Image or Rootfs must be specified.
7248    pub image: Option<String>,
7249    #[serde(skip_serializing_if = "Option::is_none")]
7250    /// ImageArch is the user-specified image architecture
7251    pub image_arch: Option<String>,
7252    #[serde(skip_serializing_if = "Option::is_none")]
7253    /// ImageOS is the user-specified image OS
7254    pub image_os: Option<String>,
7255    #[serde(skip_serializing_if = "Option::is_none")]
7256    /// ImageVariant is the user-specified image variant
7257    pub image_variant: Option<String>,
7258    #[serde(skip_serializing_if = "Option::is_none")]
7259    /// ImageVolumeMode indicates how image volumes will be created.
7260    /// Supported modes are "ignore" (do not create), "tmpfs" (create as
7261    /// tmpfs), and "anonymous" (create as anonymous volumes).
7262    /// The default if unset is anonymous.
7263    /// Optional.
7264    pub image_volume_mode: Option<String>,
7265    #[serde(skip_serializing_if = "Option::is_none")]
7266    /// Image volumes bind-mount a container-image mount into the container.
7267    /// Optional.
7268    pub image_volumes: Option<Vec<ImageVolume>>,
7269    #[serde(skip_serializing_if = "Option::is_none")]
7270    /// Init specifies that an init binary will be mounted into the
7271    /// container, and will be used as PID1.
7272    pub init: Option<bool>,
7273    #[serde(skip_serializing_if = "Option::is_none")]
7274    /// InitContainerType describes if this container is an init container
7275    /// and if so, what type: always or once
7276    pub init_container_type: Option<String>,
7277    #[serde(skip_serializing_if = "Option::is_none")]
7278    /// InitPath specifies the path to the init binary that will be added if
7279    /// Init is specified above. If not specified, the default set in the
7280    /// Libpod config will be used. Ignored if Init above is not set.
7281    /// Optional.
7282    pub init_path: Option<String>,
7283    pub ipcns: Option<Namespace>,
7284    #[serde(skip_serializing_if = "Option::is_none")]
7285    /// LabelNested indicates whether or not the container is allowed to
7286    /// run fully nested containers including labelling
7287    pub label_nested: Option<bool>,
7288    #[serde(skip_serializing_if = "Option::is_none")]
7289    /// Labels are key-value pairs that are used to add metadata to
7290    /// containers.
7291    /// Optional.
7292    pub labels: Option<HashMap<String, String>>,
7293    pub log_configuration: Option<LogConfigLibpod>,
7294    #[serde(skip_serializing_if = "Option::is_none")]
7295    /// Passwd is a container run option that determines if we are validating users/groups before running the container
7296    pub manage_password: Option<bool>,
7297    #[serde(skip_serializing_if = "Option::is_none")]
7298    /// Mask is the path we want to mask in the container. This masks the paths
7299    /// given in addition to the default list.
7300    /// Optional
7301    pub mask: Option<Vec<String>>,
7302    #[serde(skip_serializing_if = "Option::is_none")]
7303    /// Mounts are mounts that will be added to the container.
7304    /// These will supersede Image Volumes and VolumesFrom volumes where
7305    /// there are conflicts.
7306    /// Optional.
7307    pub mounts: Option<Vec<Mount>>,
7308    #[serde(skip_serializing_if = "Option::is_none")]
7309    /// Name is the name the container will be given.
7310    /// If no name is provided, one will be randomly generated.
7311    /// Optional.
7312    pub name: Option<String>,
7313    #[serde(skip_serializing_if = "Option::is_none")]
7314    /// Namespace is the libpod namespace the container will be placed in.
7315    /// Optional.
7316    pub namespace: Option<String>,
7317    pub netns: Option<Namespace>,
7318    #[serde(skip_serializing_if = "Option::is_none")]
7319    /// NetworkOptions are additional options for each network
7320    /// Optional.
7321    pub network_options: Option<HashMap<String, Vec<String>>>,
7322    #[serde(skip_serializing_if = "Option::is_none")]
7323    /// NoNewPrivileges is whether the container will set the no new
7324    /// privileges flag on create, which disables gaining additional
7325    /// privileges (e.g. via setuid) in the container.
7326    pub no_new_privileges: Option<bool>,
7327    #[serde(skip_serializing_if = "Option::is_none")]
7328    /// OCIRuntime is the name of the OCI runtime that will be used to create
7329    /// the container.
7330    /// If not specified, the default will be used.
7331    /// Optional.
7332    pub oci_runtime: Option<String>,
7333    #[serde(skip_serializing_if = "Option::is_none")]
7334    /// OOMScoreAdj adjusts the score used by the OOM killer to determine
7335    /// processes to kill for the container's process.
7336    /// Optional.
7337    pub oom_score_adj: Option<i64>,
7338    #[serde(skip_serializing_if = "Option::is_none")]
7339    /// Overlay volumes are named volumes that will be added to the container.
7340    /// Optional.
7341    pub overlay_volumes: Option<Vec<OverlayVolume>>,
7342    #[serde(skip_serializing_if = "Option::is_none")]
7343    /// PasswdEntry specifies arbitrary data to append to a file.
7344    pub passwd_entry: Option<String>,
7345    pub personality: Option<LinuxPersonality>,
7346    pub pidns: Option<Namespace>,
7347    #[serde(skip_serializing_if = "Option::is_none")]
7348    /// Pod is the ID of the pod the container will join.
7349    /// Optional.
7350    pub pod: Option<String>,
7351    #[serde(skip_serializing_if = "Option::is_none")]
7352    /// PortBindings is a set of ports to map into the container.
7353    /// Only available if NetNS is set to bridge, slirp, or pasta.
7354    /// Optional.
7355    pub portmappings: Option<Vec<PortMapping>>,
7356    #[serde(skip_serializing_if = "Option::is_none")]
7357    /// Privileged is whether the container is privileged.
7358    /// Privileged does the following:
7359    /// Adds all devices on the system to the container.
7360    /// Adds all capabilities to the container.
7361    /// Disables Seccomp, SELinux, and Apparmor confinement.
7362    /// (Though SELinux can be manually re-enabled).
7363    /// TODO: this conflicts with things.
7364    /// TODO: this does more.
7365    pub privileged: Option<bool>,
7366    #[serde(skip_serializing_if = "Option::is_none")]
7367    /// ProcOpts are the options used for the proc mount.
7368    pub procfs_opts: Option<Vec<String>>,
7369    #[serde(skip_serializing_if = "Option::is_none")]
7370    /// PublishExposedPorts will publish ports specified in the image to
7371    /// random unused ports (guaranteed to be above 1024) on the host.
7372    /// This is based on ports set in Expose below, and any ports specified
7373    /// by the Image (if one is given).
7374    /// Only available if NetNS is set to Bridge or Slirp.
7375    pub publish_image_ports: Option<bool>,
7376    #[serde(skip_serializing_if = "Option::is_none")]
7377    /// Rlimits are POSIX rlimits to apply to the container.
7378    /// Optional.
7379    pub r_limits: Option<Vec<PosixRlimit>>,
7380    #[serde(skip_serializing_if = "Option::is_none")]
7381    /// RawImageName is the user-specified and unprocessed input referring
7382    /// to a local or a remote image.
7383    pub raw_image_name: Option<String>,
7384    #[serde(skip_serializing_if = "Option::is_none")]
7385    /// ReadOnlyFilesystem indicates that everything will be mounted
7386    /// as read-only
7387    pub read_only_filesystem: Option<bool>,
7388    #[serde(skip_serializing_if = "Option::is_none")]
7389    /// ReadWriteTmpfs indicates that when running with a ReadOnlyFilesystem
7390    /// mount temporary file systems
7391    pub read_write_tmpfs: Option<bool>,
7392    #[serde(skip_serializing_if = "Option::is_none")]
7393    /// Remove indicates if the container should be removed once it has been started
7394    /// and exits
7395    pub remove: Option<bool>,
7396    pub resource_limits: Option<LinuxResources>,
7397    #[serde(skip_serializing_if = "Option::is_none")]
7398    /// RestartPolicy is the container's restart policy - an action which
7399    /// will be taken when the container exits.
7400    /// If not given, the default policy, which does nothing, will be used.
7401    /// Optional.
7402    pub restart_policy: Option<String>,
7403    #[serde(skip_serializing_if = "Option::is_none")]
7404    /// RestartRetries is the number of attempts that will be made to restart
7405    /// the container.
7406    /// Only available when RestartPolicy is set to "on-failure".
7407    /// Optional.
7408    pub restart_tries: Option<u64>,
7409    #[serde(skip_serializing_if = "Option::is_none")]
7410    /// Rootfs is the path to a directory that will be used as the
7411    /// container's root filesystem. No modification will be made to the
7412    /// directory, it will be directly mounted into the container as root.
7413    /// Conflicts with Image.
7414    /// At least one of Image or Rootfs must be specified.
7415    pub rootfs: Option<String>,
7416    #[serde(skip_serializing_if = "Option::is_none")]
7417    /// RootfsMapping specifies if there are mappings to apply to the rootfs.
7418    pub rootfs_mapping: Option<String>,
7419    #[serde(skip_serializing_if = "Option::is_none")]
7420    /// RootfsOverlay tells if rootfs is actually an overlay on top of base path
7421    pub rootfs_overlay: Option<bool>,
7422    #[serde(skip_serializing_if = "Option::is_none")]
7423    /// RootfsPropagation is the rootfs propagation mode for the container.
7424    /// If not set, the default of rslave will be used.
7425    /// Optional.
7426    pub rootfs_propagation: Option<String>,
7427    #[serde(rename = "sdnotifyMode")]
7428    #[serde(skip_serializing_if = "Option::is_none")]
7429    /// Determine how to handle the NOTIFY_SOCKET - do we participate or pass it through
7430    /// "container" - let the OCI runtime deal with it, advertise conmon's MAINPID
7431    /// "conmon-only" - advertise conmon's MAINPID, send READY when started, don't pass to OCI
7432    /// "ignore" - unset NOTIFY_SOCKET
7433    pub sdnotify_mode: Option<String>,
7434    #[serde(skip_serializing_if = "Option::is_none")]
7435    /// SeccompPolicy determines which seccomp profile gets applied
7436    /// the container. valid values: empty,default,image
7437    pub seccomp_policy: Option<String>,
7438    #[serde(skip_serializing_if = "Option::is_none")]
7439    /// SeccompProfilePath is the path to a JSON file containing the
7440    /// container's Seccomp profile.
7441    /// If not specified, no Seccomp profile will be used.
7442    /// Optional.
7443    pub seccomp_profile_path: Option<String>,
7444    #[serde(skip_serializing_if = "Option::is_none")]
7445    /// EnvSecrets are secrets that will be set as environment variables
7446    /// Optional.
7447    pub secret_env: Option<HashMap<String, String>>,
7448    #[serde(skip_serializing_if = "Option::is_none")]
7449    /// Secrets are the secrets that will be added to the container
7450    /// Optional.
7451    pub secrets: Option<Vec<Secret>>,
7452    #[serde(skip_serializing_if = "Option::is_none")]
7453    /// SelinuxProcessLabel is the process label the container will use.
7454    /// If SELinux is enabled and this is not specified, a label will be
7455    /// automatically generated if not specified.
7456    /// Optional.
7457    pub selinux_opts: Option<Vec<String>>,
7458    #[serde(skip_serializing_if = "Option::is_none")]
7459    /// ShmSize is the size of the tmpfs to mount in at /dev/shm, in bytes.
7460    /// Conflicts with ShmSize if IpcNS is not private.
7461    /// Optional.
7462    pub shm_size: Option<i64>,
7463    #[serde(skip_serializing_if = "Option::is_none")]
7464    /// ShmSizeSystemd is the size of systemd-specific tmpfs mounts
7465    /// specifically /run, /run/lock, /var/log/journal and /tmp.
7466    /// Optional
7467    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    /// Stdin is whether the container will keep its STDIN open.
7472    pub stdin: Option<bool>,
7473    pub stop_signal: Option<i64>,
7474    #[serde(skip_serializing_if = "Option::is_none")]
7475    /// StopTimeout is a timeout between the container's stop signal being
7476    /// sent and SIGKILL being sent.
7477    /// If not provided, the default will be used.
7478    /// If 0 is used, stop signal will not be sent, and SIGKILL will be sent
7479    /// instead.
7480    /// Optional.
7481    pub stop_timeout: Option<u64>,
7482    #[serde(skip_serializing_if = "Option::is_none")]
7483    /// StorageOpts is the container's storage options
7484    /// Optional.
7485    pub storage_opts: Option<HashMap<String, String>>,
7486    #[serde(skip_serializing_if = "Option::is_none")]
7487    /// Sysctl sets kernel parameters for the container
7488    pub sysctl: Option<HashMap<String, String>>,
7489    #[serde(skip_serializing_if = "Option::is_none")]
7490    /// Systemd is whether the container will be started in systemd mode.
7491    /// Valid options are "true", "false", and "always".
7492    /// "true" enables this mode only if the binary run in the container is
7493    /// sbin/init or systemd. "always" unconditionally enables systemd mode.
7494    /// "false" unconditionally disables systemd mode.
7495    /// If enabled, mounts and stop signal will be modified.
7496    /// If set to "always" or set to "true" and conditionally triggered,
7497    /// conflicts with StopSignal.
7498    /// If not specified, "false" will be assumed.
7499    /// Optional.
7500    pub systemd: Option<String>,
7501    #[serde(skip_serializing_if = "Option::is_none")]
7502    /// Terminal is whether the container will create a PTY.
7503    /// Optional.
7504    pub terminal: Option<bool>,
7505    #[serde(rename = "throttleReadBpsDevice")]
7506    #[serde(skip_serializing_if = "Option::is_none")]
7507    /// IO read rate limit per cgroup per device, bytes per second
7508    pub throttle_read_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
7509    #[serde(rename = "throttleReadIOPSDevice")]
7510    #[serde(skip_serializing_if = "Option::is_none")]
7511    /// IO read rate limit per cgroup per device, IO per second
7512    pub throttle_read_iops_device: Option<HashMap<String, LinuxThrottleDevice>>,
7513    #[serde(rename = "throttleWriteBpsDevice")]
7514    #[serde(skip_serializing_if = "Option::is_none")]
7515    /// IO write rate limit per cgroup per device, bytes per second
7516    pub throttle_write_bps_device: Option<HashMap<String, LinuxThrottleDevice>>,
7517    #[serde(rename = "throttleWriteIOPSDevice")]
7518    #[serde(skip_serializing_if = "Option::is_none")]
7519    /// IO write rate limit per cgroup per device, IO per second
7520    pub throttle_write_iops_device: Option<HashMap<String, LinuxThrottleDevice>>,
7521    #[serde(skip_serializing_if = "Option::is_none")]
7522    /// Timeout is a maximum time in seconds the container will run before
7523    /// main process is sent SIGKILL.
7524    /// If 0 is used, signal will not be sent. Container can run indefinitely
7525    /// Optional.
7526    pub timeout: Option<u64>,
7527    #[serde(skip_serializing_if = "Option::is_none")]
7528    /// Timezone is the timezone inside the container.
7529    /// Local means it has the same timezone as the host machine
7530    /// Optional.
7531    pub timezone: Option<String>,
7532    #[serde(skip_serializing_if = "Option::is_none")]
7533    /// Umask is the umask the init process of the container will be run with.
7534    pub umask: Option<String>,
7535    #[serde(skip_serializing_if = "Option::is_none")]
7536    /// CgroupConf are key-value options passed into the container runtime
7537    /// that are used to configure cgroup v2.
7538    /// Optional.
7539    pub unified: Option<HashMap<String, String>>,
7540    #[serde(skip_serializing_if = "Option::is_none")]
7541    /// Unmask is the path we want to unmask in the container. To override
7542    /// all the default paths that are masked, set unmask=ALL.
7543    pub unmask: Option<Vec<String>>,
7544    #[serde(skip_serializing_if = "Option::is_none")]
7545    /// UnsetEnv unsets the specified default environment variables from the image or from buildin or containers.conf
7546    /// Optional.
7547    pub unsetenv: Option<Vec<String>>,
7548    #[serde(skip_serializing_if = "Option::is_none")]
7549    /// UnsetEnvAll unsetall default environment variables from the image or from buildin or containers.conf
7550    /// UnsetEnvAll unsets all default environment variables from the image or from buildin
7551    /// Optional.
7552    pub unsetenvall: Option<bool>,
7553    #[serde(skip_serializing_if = "Option::is_none")]
7554    /// UseImageHosts indicates that /etc/hosts should not be managed by
7555    /// Podman, and instead sourced from the image.
7556    /// Conflicts with HostAdd.
7557    /// Do not set omitempty here, if this is false it should be set to not get
7558    /// the server default.
7559    /// Ideally this would be a pointer so we could differentiate between an
7560    /// explicitly false/true and unset (containers.conf default). However
7561    /// specgen is stable so we can not change this right now.
7562    /// TODO (5.0): change to pointer
7563    pub use_image_hosts: Option<bool>,
7564    #[serde(skip_serializing_if = "Option::is_none")]
7565    /// UseImageResolvConf indicates that resolv.conf should not be managed
7566    /// by Podman, but instead sourced from the image.
7567    /// Conflicts with DNSServer, DNSSearch, DNSOption.
7568    pub use_image_resolve_conf: Option<bool>,
7569    #[serde(skip_serializing_if = "Option::is_none")]
7570    /// User is the user the container will be run as.
7571    /// Can be given as a UID or a username; if a username, it will be
7572    /// resolved within the container, using the container's /etc/passwd.
7573    /// If unset, the container will be run as root.
7574    /// Optional.
7575    pub user: Option<String>,
7576    pub userns: Option<Namespace>,
7577    pub utsns: Option<Namespace>,
7578    #[serde(skip_serializing_if = "Option::is_none")]
7579    /// Volatile specifies whether the container storage can be optimized
7580    /// at the cost of not syncing all the dirty files in memory.
7581    pub volatile: Option<bool>,
7582    #[serde(skip_serializing_if = "Option::is_none")]
7583    /// Volumes are named volumes that will be added to the container.
7584    /// These will supersede Image Volumes and VolumesFrom volumes where
7585    /// there are conflicts.
7586    /// Optional.
7587    pub volumes: Option<Vec<NamedVolume>>,
7588    #[serde(skip_serializing_if = "Option::is_none")]
7589    /// VolumesFrom is a set of containers whose volumes will be added to
7590    /// this container. The name or ID of the container must be provided, and
7591    /// may optionally be followed by a : and then one or more
7592    /// comma-separated options. Valid options are 'ro', 'rw', and 'z'.
7593    /// Options will be used for all volumes sourced from the container.
7594    pub volumes_from: Option<Vec<String>>,
7595    #[serde(rename = "weightDevice")]
7596    #[serde(skip_serializing_if = "Option::is_none")]
7597    /// Weight per cgroup per device, can override BlkioWeight
7598    pub weight_device: Option<HashMap<String, LinuxWeightDevice>>,
7599    #[serde(skip_serializing_if = "Option::is_none")]
7600    /// WorkDir is the container's working directory.
7601    /// If unset, the default, /, will be used.
7602    /// Optional.
7603    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    /// Retries is the number of consecutive failures needed to consider a container as unhealthy.
7613    /// Zero means inherit.
7614    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    /// Successes are the number of successes required to mark the startup HC
7620    /// as passed.
7621    /// If set to 0, a single success will mark the HC as passed.
7622    pub successes: Option<i64>,
7623    #[serde(rename = "Test")]
7624    #[serde(skip_serializing_if = "Option::is_none")]
7625    /// Test is the test to perform to check that the container is healthy.
7626    /// An empty slice means to inherit the default.
7627    /// The options are:
7628    /// {} : inherit healthcheck
7629    /// {"NONE"} : disable healthcheck
7630    /// {"CMD", args...} : exec arguments directly
7631    /// {"CMD-SHELL", command} : run command with system's default shell
7632    pub test: Option<Vec<String>>,
7633    #[serde(rename = "Timeout")]
7634    pub timeout: Option<i64>,
7635}
7636
7637/// We need to override the json decoder to accept both options.
7638pub type StrSlice = Vec<String>;
7639
7640#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7641pub struct Subnet {
7642    #[serde(skip_serializing_if = "Option::is_none")]
7643    /// Gateway IP for this Network.
7644    pub gateway: Option<String>,
7645    pub lease_range: Option<LeaseRange>,
7646    #[serde(skip_serializing_if = "Option::is_none")]
7647    /// Subnet for this Network in CIDR form.
7648    pub subnet: Option<String>,
7649}
7650
7651#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7652/// SummaryNetworkSettings provides a summary of container's networks
7653/// in /containers/json
7654pub 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)]
7661/// SystemDfContainerReport describes a container for use with df
7662pub 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)]
7693/// SystemDfImageReport describes an image for use with df
7694pub 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)]
7722/// SystemDfReport describes the response for df information
7723pub 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)]
7739/// SystemDfVolumeReport describes a volume and its size
7740pub 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
7755/// Success
7756pub 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)]
7781/// Task carries the information about one backend task
7782pub 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)]
7798/// ThrottleDevice is a structure that holds device:rate_per_second pair
7799pub 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    /// Size sets the size of the tmpfs, in bytes.
7815    ///
7816    /// This will be converted to an operating system specific value
7817    /// depending on the host. For example, on linux, it will be converted to
7818    /// use a 'k', 'm' or 'g' syntax. BSD, though not widely supported with
7819    /// docker, uses a straight byte value.
7820    ///
7821    /// Percentages are not supported.
7822    pub size_bytes: Option<i64>,
7823}
7824
7825#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7826/// This description is taken verbatim from the CSI Spec:
7827///
7828/// A topological domain is a sub-division of a cluster, like "region",
7829/// "zone", "rack", etc.
7830/// A topological segment is a specific instance of a topological domain,
7831/// like "zone3", "rack3", etc.
7832/// For example {"com.company/zone": "Z1", "com.company/rack": "R3"}
7833/// Valid keys have two segments: an OPTIONAL prefix and name, separated
7834/// by a slash (/), for example: "com.company.example/zone".
7835/// The key name segment is REQUIRED. The prefix is OPTIONAL.
7836/// The key name MUST be 63 characters or less, begin and end with an
7837/// alphanumeric character ([a-z0-9A-Z]), and contain only dashes (-),
7838/// underscores (_), dots (.), or alphanumerics in between, for example
7839/// "zone".
7840/// The key prefix MUST be 63 characters or less, begin and end with a
7841/// lower-case alphanumeric character ([a-z0-9]), contain only
7842/// dashes (-), dots (.), or lower-case alphanumerics in between, and
7843/// follow domain name notation format
7844/// (https://tools.ietf.org/html/rfc1035#section-2.3.1).
7845/// The key prefix SHOULD include the plugin's host company name and/or
7846/// the plugin name, to minimize the possibility of collisions with keys
7847/// from other plugins.
7848/// If a key prefix is specified, it MUST be identical across all
7849/// topology keys returned by the SP (across all RPCs).
7850/// Keys MUST be case-insensitive. Meaning the keys "Zone" and "zone"
7851/// MUST not both exist.
7852/// Each value (topological segment) MUST contain 1 or more strings.
7853/// Each string MUST be 63 characters or less and begin and end with an
7854/// alphanumeric character with '-', '_', '.', or alphanumerics in
7855/// between.
7856pub 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)]
7863/// TopologyRequirement expresses the user's requirements for a volume's
7864/// accessible topology.
7865pub struct TopologyRequirement {
7866    #[serde(rename = "Preferred")]
7867    #[serde(skip_serializing_if = "Option::is_none")]
7868    /// Preferred is a list of Topologies that the volume should attempt to be
7869    /// provisioned in.
7870    ///
7871    /// Taken from the CSI spec:
7872    ///
7873    /// Specifies the list of topologies the CO would prefer the volume to
7874    /// be provisioned in.
7875    ///
7876    /// This field is OPTIONAL. If TopologyRequirement is specified either
7877    /// requisite or preferred or both MUST be specified.
7878    ///
7879    /// An SP MUST attempt to make the provisioned volume available using
7880    /// the preferred topologies in order from first to last.
7881    ///
7882    /// If requisite is specified, all topologies in preferred list MUST
7883    /// also be present in the list of requisite topologies.
7884    ///
7885    /// If the SP is unable to to make the provisioned volume available
7886    /// from any of the preferred topologies, the SP MAY choose a topology
7887    /// from the list of requisite topologies.
7888    /// If the list of requisite topologies is not specified, then the SP
7889    /// MAY choose from the list of all possible topologies.
7890    /// If the list of requisite topologies is specified and the SP is
7891    /// unable to to make the provisioned volume available from any of the
7892    /// requisite topologies it MUST fail the CreateVolume call.
7893    ///
7894    /// Example 1:
7895    /// Given a volume should be accessible from a single zone, and
7896    /// requisite =
7897    /// {"region": "R1", "zone": "Z2"},
7898    /// {"region": "R1", "zone": "Z3"}
7899    /// preferred =
7900    /// {"region": "R1", "zone": "Z3"}
7901    /// then the the SP SHOULD first attempt to make the provisioned volume
7902    /// available from "zone" "Z3" in the "region" "R1" and fall back to
7903    /// "zone" "Z2" in the "region" "R1" if that is not possible.
7904    ///
7905    /// Example 2:
7906    /// Given a volume should be accessible from a single zone, and
7907    /// requisite =
7908    /// {"region": "R1", "zone": "Z2"},
7909    /// {"region": "R1", "zone": "Z3"},
7910    /// {"region": "R1", "zone": "Z4"},
7911    /// {"region": "R1", "zone": "Z5"}
7912    /// preferred =
7913    /// {"region": "R1", "zone": "Z4"},
7914    /// {"region": "R1", "zone": "Z2"}
7915    /// then the the SP SHOULD first attempt to make the provisioned volume
7916    /// accessible from "zone" "Z4" in the "region" "R1" and fall back to
7917    /// "zone" "Z2" in the "region" "R1" if that is not possible. If that
7918    /// is not possible, the SP may choose between either the "zone"
7919    /// "Z3" or "Z5" in the "region" "R1".
7920    ///
7921    /// Example 3:
7922    /// Given a volume should be accessible from TWO zones (because an
7923    /// opaque parameter in CreateVolumeRequest, for example, specifies
7924    /// the volume is accessible from two zones, aka synchronously
7925    /// replicated), and
7926    /// requisite =
7927    /// {"region": "R1", "zone": "Z2"},
7928    /// {"region": "R1", "zone": "Z3"},
7929    /// {"region": "R1", "zone": "Z4"},
7930    /// {"region": "R1", "zone": "Z5"}
7931    /// preferred =
7932    /// {"region": "R1", "zone": "Z5"},
7933    /// {"region": "R1", "zone": "Z3"}
7934    /// then the the SP SHOULD first attempt to make the provisioned volume
7935    /// accessible from the combination of the two "zones" "Z5" and "Z3" in
7936    /// the "region" "R1". If that's not possible, it should fall back to
7937    /// a combination of "Z5" and other possibilities from the list of
7938    /// requisite. If that's not possible, it should fall back  to a
7939    /// combination of "Z3" and other possibilities from the list of
7940    /// requisite. If that's not possible, it should fall back  to a
7941    /// combination of other possibilities from the list of requisite.
7942    pub preferred: Option<Vec<Topology>>,
7943    #[serde(rename = "Requisite")]
7944    #[serde(skip_serializing_if = "Option::is_none")]
7945    /// Requisite specifies a list of Topologies, at least one of which the
7946    /// volume must be accessible from.
7947    ///
7948    /// Taken verbatim from the CSI Spec:
7949    ///
7950    /// Specifies the list of topologies the provisioned volume MUST be
7951    /// accessible from.
7952    /// This field is OPTIONAL. If TopologyRequirement is specified either
7953    /// requisite or preferred or both MUST be specified.
7954    ///
7955    /// If requisite is specified, the provisioned volume MUST be
7956    /// accessible from at least one of the requisite topologies.
7957    ///
7958    /// Given
7959    /// x = number of topologies provisioned volume is accessible from
7960    /// n = number of requisite topologies
7961    /// The CO MUST ensure n >= 1. The SP MUST ensure x >= 1
7962    /// If x==n, then the SP MUST make the provisioned volume available to
7963    /// all topologies from the list of requisite topologies. If it is
7964    /// unable to do so, the SP MUST fail the CreateVolume call.
7965    /// For example, if a volume should be accessible from a single zone,
7966    /// and requisite =
7967    /// {"region": "R1", "zone": "Z2"}
7968    /// then the provisioned volume MUST be accessible from the "region"
7969    /// "R1" and the "zone" "Z2".
7970    /// Similarly, if a volume should be accessible from two zones, and
7971    /// requisite =
7972    /// {"region": "R1", "zone": "Z2"},
7973    /// {"region": "R1", "zone": "Z3"}
7974    /// then the provisioned volume MUST be accessible from the "region"
7975    /// "R1" and both "zone" "Z2" and "zone" "Z3".
7976    ///
7977    /// If x<n, then the SP SHALL choose x unique topologies from the list
7978    /// of requisite topologies. If it is unable to do so, the SP MUST fail
7979    /// the CreateVolume call.
7980    /// For example, if a volume should be accessible from a single zone,
7981    /// and requisite =
7982    /// {"region": "R1", "zone": "Z2"},
7983    /// {"region": "R1", "zone": "Z3"}
7984    /// then the SP may choose to make the provisioned volume available in
7985    /// either the "zone" "Z2" or the "zone" "Z3" in the "region" "R1".
7986    /// Similarly, if a volume should be accessible from two zones, and
7987    /// requisite =
7988    /// {"region": "R1", "zone": "Z2"},
7989    /// {"region": "R1", "zone": "Z3"},
7990    /// {"region": "R1", "zone": "Z4"}
7991    /// then the provisioned volume MUST be accessible from any combination
7992    /// of two unique topologies: e.g. "R1/Z2" and "R1/Z3", or "R1/Z2" and
7993    /// "R1/Z4", or "R1/Z3" and "R1/Z4".
7994    ///
7995    /// If x>n, then the SP MUST make the provisioned volume available from
7996    /// all topologies from the list of requisite topologies and MAY choose
7997    /// the remaining x-n unique topologies from the list of all possible
7998    /// topologies. If it is unable to do so, the SP MUST fail the
7999    /// CreateVolume call.
8000    /// For example, if a volume should be accessible from two zones, and
8001    /// requisite =
8002    /// {"region": "R1", "zone": "Z2"}
8003    /// then the provisioned volume MUST be accessible from the "region"
8004    /// "R1" and the "zone" "Z2" and the SP may select the second zone
8005    /// independently, e.g. "R1/Z4".
8006    pub requisite: Option<Vec<Topology>>,
8007}
8008
8009pub type Type = String;
8010
8011/// Intentionally empty.
8012pub type TypeBlock = Value;
8013
8014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8015/// TypeMount contains options for using a volume as a Mount-type
8016/// volume.
8017pub struct TypeMount {
8018    #[serde(rename = "FsType")]
8019    #[serde(skip_serializing_if = "Option::is_none")]
8020    /// FsType specifies the filesystem type for the mount volume. Optional.
8021    pub fs_type: Option<String>,
8022    #[serde(rename = "MountFlags")]
8023    #[serde(skip_serializing_if = "Option::is_none")]
8024    /// MountFlags defines flags to pass when mounting the volume. Optional.
8025    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)]
8044/// UpdateEntities used to wrap the oci resource spec in a swagger model
8045pub struct UpdateEntities {
8046    #[serde(rename = "Resources")]
8047    pub resources: Option<LinuxResources>,
8048}
8049
8050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8051/// UsageData Usage details about the volume. This information is used by the
8052/// `GET /system/df` endpoint, and omitted in other endpoints.
8053pub struct UsageData {
8054    #[serde(rename = "RefCount")]
8055    /// The number of containers referencing this volume. This field
8056    /// is set to `-1` if the reference-count is not available.
8057    pub ref_count: i64,
8058    #[serde(rename = "Size")]
8059    /// Amount of disk space used by the volume (in bytes). This information
8060    /// is only available for volumes created with the `"local"` volume
8061    /// driver. For volumes created with other volume drivers, this field
8062    /// is set to `-1` ("not available")
8063    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)]
8076/// Volume volume
8077pub 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    /// Date/Time the volume was created.
8083    pub created_at: Option<String>,
8084    #[serde(rename = "Driver")]
8085    /// Name of the volume driver used by the volume.
8086    pub driver: String,
8087    #[serde(rename = "Labels")]
8088    #[serde(default)]
8089    #[serde(deserialize_with = "deserialize_nonoptional_map")]
8090    /// User-defined key/value metadata.
8091    pub labels: HashMap<String, String>,
8092    #[serde(rename = "Mountpoint")]
8093    /// Mount path of the volume on the host.
8094    pub mountpoint: String,
8095    #[serde(rename = "Name")]
8096    /// Name of the volume.
8097    pub name: String,
8098    #[serde(rename = "Options")]
8099    #[serde(default)]
8100    #[serde(deserialize_with = "deserialize_nonoptional_map")]
8101    /// The driver specific options used when creating the volume.
8102    pub options: HashMap<String, String>,
8103    #[serde(rename = "Scope")]
8104    /// The level at which the volume exists. Either `global` for cluster-wide,
8105    /// or `local` for machine level.
8106    pub scope: String,
8107    #[serde(rename = "Status")]
8108    #[serde(skip_serializing_if = "Option::is_none")]
8109    /// Low-level details about the volume, provided by the volume driver.
8110    /// Details are returned as a map with key/value pairs:
8111    /// `{"key":"value","key2":"value2"}`.
8112    ///
8113    /// The `Status` field is optional, and is omitted if the volume driver
8114    /// does not support this feature.
8115    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    /// Anonymous indicates that the volume was created as an anonymous
8125    /// volume for a specific container, and will be removed when any
8126    /// container using it is removed.
8127    pub anonymous: Option<bool>,
8128    #[serde(rename = "CreatedAt")]
8129    #[serde(skip_serializing_if = "Option::is_none")]
8130    /// CreatedAt is the date and time the volume was created at. This is not
8131    /// stored for older Libpod volumes; if so, it will be omitted.
8132    pub created_at: Option<DateTime<Utc>>,
8133    #[serde(rename = "Driver")]
8134    #[serde(skip_serializing_if = "Option::is_none")]
8135    /// Driver is the driver used to create the volume.
8136    /// If set to "local" or "", the Local driver (Podman built-in code) is
8137    /// used to service the volume; otherwise, a volume plugin with the given
8138    /// name is used to mount and manage the volume.
8139    pub driver: Option<String>,
8140    #[serde(rename = "GID")]
8141    #[serde(skip_serializing_if = "Option::is_none")]
8142    /// GID is the GID that the volume was created with.
8143    pub gid: Option<i64>,
8144    #[serde(rename = "Labels")]
8145    #[serde(skip_serializing_if = "Option::is_none")]
8146    /// Labels includes the volume's configured labels, key:value pairs that
8147    /// can be passed during volume creation to provide information for third
8148    /// party tools.
8149    pub labels: Option<HashMap<String, String>>,
8150    #[serde(rename = "MountCount")]
8151    #[serde(skip_serializing_if = "Option::is_none")]
8152    /// MountCount is the number of times this volume has been mounted.
8153    pub mount_count: Option<u64>,
8154    #[serde(rename = "Mountpoint")]
8155    #[serde(skip_serializing_if = "Option::is_none")]
8156    /// Mountpoint is the path on the host where the volume is mounted.
8157    pub mountpoint: Option<String>,
8158    #[serde(rename = "Name")]
8159    #[serde(skip_serializing_if = "Option::is_none")]
8160    /// Name is the name of the volume.
8161    pub name: Option<String>,
8162    #[serde(rename = "NeedsChown")]
8163    #[serde(skip_serializing_if = "Option::is_none")]
8164    /// NeedsChown indicates that the next time the volume is mounted into
8165    /// a container, the container will chown the volume to the container process
8166    /// UID/GID.
8167    pub needs_chown: Option<bool>,
8168    #[serde(rename = "NeedsCopyUp")]
8169    #[serde(skip_serializing_if = "Option::is_none")]
8170    /// NeedsCopyUp indicates that the next time the volume is mounted into
8171    pub needs_copy_up: Option<bool>,
8172    #[serde(rename = "Options")]
8173    #[serde(skip_serializing_if = "Option::is_none")]
8174    /// Options is a set of options that were used when creating the volume.
8175    /// For the Local driver, these are mount options that will be used to
8176    /// determine how a local filesystem is mounted; they are handled as
8177    /// parameters to Mount in a manner described in the volume create
8178    /// manpage.
8179    /// For non-local drivers, these are passed as-is to the volume plugin.
8180    pub options: Option<HashMap<String, String>>,
8181    #[serde(rename = "Scope")]
8182    #[serde(skip_serializing_if = "Option::is_none")]
8183    /// Scope is unused and provided solely for Docker compatibility. It is
8184    /// unconditionally set to "local".
8185    pub scope: Option<String>,
8186    #[serde(rename = "Status")]
8187    #[serde(skip_serializing_if = "Option::is_none")]
8188    /// Status is used to return information on the volume's current state,
8189    /// if the volume was created using a volume plugin (uses a Driver that
8190    /// is not the local driver).
8191    /// Status is provided to us by an external program, so no guarantees are
8192    /// made about its format or contents. Further, it is an optional field,
8193    /// so it may not be set even in cases where a volume plugin is in use.
8194    pub status: Option<Value>,
8195    #[serde(rename = "StorageID")]
8196    #[serde(skip_serializing_if = "Option::is_none")]
8197    /// StorageID is the ID of the container backing the volume in c/storage.
8198    /// Only used with Image Volumes.
8199    pub storage_id: Option<String>,
8200    #[serde(rename = "Timeout")]
8201    #[serde(skip_serializing_if = "Option::is_none")]
8202    /// Timeout is the specified driver timeout if given
8203    pub timeout: Option<u64>,
8204    #[serde(rename = "UID")]
8205    #[serde(skip_serializing_if = "Option::is_none")]
8206    /// UID is the UID that the volume was created with.
8207    pub uid: Option<i64>,
8208}
8209
8210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8211/// VolumeCreateOptions provides details for creating volumes
8212pub struct VolumeCreateOptions {
8213    #[serde(rename = "Driver")]
8214    #[serde(skip_serializing_if = "Option::is_none")]
8215    /// Volume driver to use
8216    pub driver: Option<String>,
8217    #[serde(rename = "IgnoreIfExists")]
8218    #[serde(skip_serializing_if = "Option::is_none")]
8219    /// Ignore existing volumes
8220    pub ignore_if_exists: Option<bool>,
8221    #[serde(rename = "Label")]
8222    #[serde(skip_serializing_if = "Option::is_none")]
8223    /// User-defined key/value metadata. Provided for compatibility
8224    pub label: Option<HashMap<String, String>>,
8225    #[serde(rename = "Labels")]
8226    #[serde(skip_serializing_if = "Option::is_none")]
8227    /// User-defined key/value metadata. Preferred field, will override Label
8228    pub labels: Option<HashMap<String, String>>,
8229    #[serde(rename = "Name")]
8230    #[serde(skip_serializing_if = "Option::is_none")]
8231    /// New volume's name. Can be left blank
8232    pub name: Option<String>,
8233    #[serde(rename = "Options")]
8234    #[serde(skip_serializing_if = "Option::is_none")]
8235    /// Mapping of driver options and values.
8236    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)]
8262/// POST "/volumes/prune"
8263pub 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)]
8273/// WaitExitError container waiting error, if any
8274pub struct WaitExitError {
8275    #[serde(rename = "Message")]
8276    #[serde(skip_serializing_if = "Option::is_none")]
8277    /// Details of an error
8278    pub message: Option<String>,
8279}
8280
8281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8282/// OK response to ContainerWait operation
8283pub struct WaitResponse {
8284    #[serde(rename = "Error")]
8285    pub error: Option<WaitExitError>,
8286    #[serde(rename = "StatusCode")]
8287    /// Exit code of the container
8288    pub status_code: i64,
8289}
8290
8291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8292/// WeightDevice is a structure that holds device:weight pair
8293pub 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
8302/// Remove Containers
8303pub type ContainerRemoveLibpod = Vec<LibpodContainersRmReport>;
8304
8305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8306/// Wait container
8307pub 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    /// container exit code
8314    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
8324/// List Containers
8325pub type ContainersList = Vec<Container>;
8326
8327/// List Containers
8328pub type ContainersListLibpod = Vec<ListContainer>;
8329
8330/// Prune Containers
8331pub type ContainersPrune = Vec<ContainersPruneReport>;
8332
8333/// Prune Containers
8334pub type ContainersPruneLibpod = Vec<ContainersPruneReportLibpod>;
8335
8336/// Image Delete
8337pub 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
8347/// Image summary for compat API
8348pub type ImageList = Vec<ImageSummary>;
8349
8350/// Image summary for libpod API
8351pub type ImageListLibpod = Vec<LibpodImageSummary>;
8352
8353/// Image Prune
8354pub type ImagesPruneLibpod = Vec<PruneReport>;
8355
8356#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8357/// Network create
8358pub struct NetworkCreateLibpod {
8359    #[serde(skip_serializing_if = "Option::is_none")]
8360    /// Created contains the timestamp when this network was created.
8361    pub created: Option<DateTime<Utc>>,
8362    #[serde(skip_serializing_if = "Option::is_none")]
8363    /// DNSEnabled is whether name resolution is active for container on
8364    /// this Network. Only supported with the bridge driver.
8365    pub dns_enabled: Option<bool>,
8366    #[serde(skip_serializing_if = "Option::is_none")]
8367    /// Driver for this Network, e.g. bridge, macvlan...
8368    pub driver: Option<String>,
8369    #[serde(skip_serializing_if = "Option::is_none")]
8370    /// ID of the Network.
8371    pub id: Option<String>,
8372    #[serde(skip_serializing_if = "Option::is_none")]
8373    /// Internal is whether the Network should not have external routes
8374    /// to public or other Networks.
8375    pub internal: Option<bool>,
8376    #[serde(skip_serializing_if = "Option::is_none")]
8377    /// IPAMOptions contains options used for the ip assignment.
8378    pub ipam_options: Option<HashMap<String, String>>,
8379    #[serde(rename = "ipv6_enabled")]
8380    #[serde(skip_serializing_if = "Option::is_none")]
8381    /// IPv6Enabled if set to true an ipv6 subnet should be created for this net.
8382    pub ipv_6_enabled: Option<bool>,
8383    #[serde(skip_serializing_if = "Option::is_none")]
8384    /// Labels is a set of key-value labels that have been applied to the
8385    /// Network.
8386    pub labels: Option<HashMap<String, String>>,
8387    #[serde(skip_serializing_if = "Option::is_none")]
8388    /// Name of the Network.
8389    pub name: Option<String>,
8390    #[serde(skip_serializing_if = "Option::is_none")]
8391    /// List of custom DNS server for podman's DNS resolver at network level,
8392    /// all the containers attached to this network will consider resolvers
8393    /// configured at network level.
8394    pub network_dns_servers: Option<Vec<String>>,
8395    #[serde(skip_serializing_if = "Option::is_none")]
8396    /// NetworkInterface is the network interface name on the host.
8397    pub network_interface: Option<String>,
8398    #[serde(skip_serializing_if = "Option::is_none")]
8399    /// Options is a set of key-value options that have been applied to
8400    /// the Network.
8401    pub options: Option<HashMap<String, String>>,
8402    #[serde(skip_serializing_if = "Option::is_none")]
8403    /// Subnets to use for this network.
8404    pub subnets: Option<Vec<Subnet>>,
8405}
8406
8407/// Network list
8408pub type NetworkListCompat = Vec<NetworkResource>;
8409
8410/// Network list
8411pub type NetworkListLibpod = Vec<Network>;
8412
8413/// Network prune
8414pub type NetworkPruneResponse = Vec<NetworkPruneReport>;
8415
8416/// Network Delete
8417pub type NetworkRmResponse = Vec<NetworkRmReport>;
8418
8419/// Success
8420pub type Ok = Value;
8421
8422/// Pod Statistics
8423pub type PodStatsResponse = Vec<PodStatsReport>;
8424
8425/// List pods
8426pub type PodsListResponse = Vec<ListPodsReport>;
8427
8428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8429/// Registry Search
8430pub struct RegistrySearchResponse {
8431    #[serde(rename = "Automated")]
8432    #[serde(skip_serializing_if = "Option::is_none")]
8433    /// Automated indicates if the image was created by an automated build.
8434    pub automated: Option<String>,
8435    #[serde(rename = "Description")]
8436    #[serde(skip_serializing_if = "Option::is_none")]
8437    /// Description of the image.
8438    pub description: Option<String>,
8439    #[serde(rename = "Index")]
8440    #[serde(skip_serializing_if = "Option::is_none")]
8441    /// Index is the image index
8442    pub index: Option<String>,
8443    #[serde(rename = "Name")]
8444    #[serde(skip_serializing_if = "Option::is_none")]
8445    /// Name is the canonical name of the image
8446    pub name: Option<String>,
8447    #[serde(rename = "Official")]
8448    #[serde(skip_serializing_if = "Option::is_none")]
8449    /// Official indicates if it's an official image.
8450    pub official: Option<String>,
8451    #[serde(rename = "Stars")]
8452    #[serde(skip_serializing_if = "Option::is_none")]
8453    /// Stars is the number of stars of the image.
8454    pub stars: Option<i64>,
8455    #[serde(rename = "Tag")]
8456    #[serde(skip_serializing_if = "Option::is_none")]
8457    /// Tag is the image tag
8458    pub tag: Option<String>,
8459}
8460
8461#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8462/// Details for creating a volume
8463pub struct VolumeCreate {
8464    #[serde(rename = "Driver")]
8465    /// Name of the volume driver to use.
8466    pub driver: String,
8467    #[serde(rename = "DriverOpts")]
8468    #[serde(default)]
8469    #[serde(deserialize_with = "deserialize_nonoptional_map")]
8470    /// A mapping of driver options and values. These options are
8471    /// passed directly to the driver and are driver specific.
8472    pub driver_opts: HashMap<String, String>,
8473    #[serde(rename = "Labels")]
8474    #[serde(default)]
8475    #[serde(deserialize_with = "deserialize_nonoptional_map")]
8476    /// User-defined key/value metadata.
8477    pub labels: HashMap<String, String>,
8478    #[serde(rename = "Name")]
8479    /// The new volume's name. If not specified, Docker generates a name.
8480    pub name: String,
8481}
8482
8483/// Volume list
8484pub type VolumeListLibpod = Vec<VolumeConfigResponse>;
8485
8486/// Volume Prune
8487pub type VolumePruneLibpod = Vec<PruneReport>;
8488
8489/// CreateContainerConfig used when compatible endpoint creates a container
8490pub type ContainerCreateBodyParam = CreateContainerConfig;
8491
8492/// SpecGenerator creates an OCI spec and Libpod configuration options to create
8493/// a container based on the given configuration.
8494pub type ContainerCreateLibpodCreateParam = SpecGenerator;
8495
8496/// UpdateEntities used to wrap the oci resource spec in a swagger model
8497pub type ContainerUpdateLibpodResourcesParam = UpdateEntities;
8498
8499/// ManifestAddOptions provides model for adding digests to manifest list
8500pub type ManifestAddLibpodOptionsParam = ManifestAddOptions;
8501
8502/// swagger 2.0 does not support oneOf for schema validation.
8503///
8504/// Operation "update" uses all fields.
8505/// Operation "remove" uses fields: Operation and Images
8506/// Operation "annotate" uses fields: Operation and Annotations
8507pub type ManifestCreateLibpodOptionsParam = ManifestModifyOptions;
8508
8509/// swagger 2.0 does not support oneOf for schema validation.
8510///
8511/// Operation "update" uses all fields.
8512/// Operation "remove" uses fields: Operation and Images
8513/// Operation "annotate" uses fields: Operation and Annotations
8514pub type ManifestModifyLibpodOptionsParam = ManifestModifyOptions;
8515
8516/// Network create
8517pub type NetworkCreateLibpodCreateParam = NetworkCreateLibpod;
8518
8519/// PodSpecGenerator describes options to create a pod
8520pub type PodCreateLibpodCreateParam = PodSpecGenerator;
8521
8522pub type SecretCreateCreateParam = SecretCreate;
8523
8524pub type SecretInspectCompatResponse = SecretInfoReportCompat;
8525
8526pub type SecretInspectResponse = SecretInfoReport;
8527
8528/// AuthConfig contains authorization information for connecting to a Registry
8529pub type SystemAuthAuthConfigParam = AuthConfig;
8530
8531/// Details for creating a volume
8532pub type VolumeCreateCreateParam = VolumeCreate;
8533
8534/// VolumeCreateOptions provides details for creating volumes
8535pub type VolumeCreateLibpodCreateParam = VolumeCreateOptions;
8536
8537/// ErrorModel is used in remote connections with podman
8538pub type BadParamError = ErrorModel;
8539
8540/// ErrorModel is used in remote connections with podman
8541pub type ConflictError = ErrorModel;
8542
8543/// ErrorModel is used in remote connections with podman
8544pub type ContainerAlreadyStartedError = ErrorModel;
8545
8546/// ErrorModel is used in remote connections with podman
8547pub type ContainerAlreadyStoppedError = ErrorModel;
8548
8549/// ContainerJSON is newly used struct along with MountPoint
8550pub type ContainerInspectResponse = ContainerJson;
8551
8552/// InspectContainerData provides a detailed record of a container's configuration
8553/// and state as viewed by Libpod.
8554/// Large portions of this structure are defined such that the output is
8555/// compatible with `docker inspect` JSON, but additional fields have been added
8556/// as required to share information not in the original output.
8557pub type ContainerInspectResponseLibpod = InspectContainerData;
8558
8559/// ErrorModel is used in remote connections with podman
8560pub type ContainerNotFound = ErrorModel;
8561
8562/// ContainerTopOKBody OK response to ContainerTop operation
8563pub type ContainerTopResponse = ContainerTopOkBody;
8564
8565pub type ExecSessionInspect = InspectExecSession;
8566
8567/// ErrorModel is used in remote connections with podman
8568pub type ExecSessionNotFound = ErrorModel;
8569
8570/// HealthCheckResults describes the results/logs from a healthcheck
8571pub type HealthCheck = HealthCheckResults;
8572
8573/// ErrorModel is used in remote connections with podman
8574pub type ImageNotFound = ErrorModel;
8575
8576pub type ImagesImportResponseLibpod = ImageImportReport;
8577
8578pub type ImagesLoadResponseLibpod = ImageLoadReport;
8579
8580pub type ImagesPullResponseLibpod = LibpodImagesPullReport;
8581
8582/// LibpodImagesRemoveReport is the return type for image removal via the rest
8583/// api.
8584pub type ImagesRemoveResponseLibpod = LibpodImagesRemoveReport;
8585
8586pub type ImagesScpResponseLibpod = ScpReport;
8587
8588/// Info contains information about the Volume as a whole as provided by
8589/// the CSI storage plugin.
8590pub type InfoResponse = Info;
8591
8592pub type InspectImageResponseLibpod = ImageData;
8593
8594/// ErrorModel is used in remote connections with podman
8595pub type InternalError = ErrorModel;
8596
8597/// This is publicly visible as c/image/manifest.Schema2List.
8598/// Internal users should usually use Schema2List instead.
8599pub type ManifestInspect = Schema2ListPublic;
8600
8601/// ErrorModel is used in remote connections with podman
8602pub type ManifestNotFound = ErrorModel;
8603
8604/// NetworkConnect represents the data to be used to connect a container to the network
8605pub type NetworkConnectRequest = NetworkConnect;
8606
8607/// NetworkConnectOptions describes options for connecting
8608/// a container to a network
8609pub type NetworkConnectRequestLibpod = NetworkConnectOptions;
8610
8611pub type NetworkCreateResponse = Network;
8612
8613/// NetworkDisconnect represents the data to be used to disconnect a container from the network
8614pub type NetworkDisconnectRequest = NetworkDisconnect;
8615
8616/// NetworkResource is the body of the "get network" http response message
8617pub type NetworkInspectCompat = NetworkResource;
8618
8619pub type NetworkInspectResponse = Network;
8620
8621/// ErrorModel is used in remote connections with podman
8622pub type NetworkNotFound = ErrorModel;
8623
8624/// NetworkUpdateOptions describes options to update a network
8625pub type NetworkUpdateRequestLibpod = NetworkUpdateOptions;
8626
8627pub type PlayKubeResponseLibpod = PlayKubeReport;
8628
8629/// ErrorModel is used in remote connections with podman
8630pub type PodAlreadyStartedError = ErrorModel;
8631
8632/// ErrorModel is used in remote connections with podman
8633pub type PodAlreadyStoppedError = ErrorModel;
8634
8635/// InspectPodData contains detailed information on a pod's configuration and
8636/// state. It is used as the output of Inspect on pods.
8637pub type PodInspectResponse = InspectPodData;
8638
8639pub type PodKillResponse = PodKillReport;
8640
8641/// ErrorModel is used in remote connections with podman
8642pub 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
8660/// AuthReport describes the response for authentication check
8661pub type SystemAuthResponse = AuthReport;
8662
8663/// SystemDfReport describes the response for df information
8664pub type SystemDiskUsage = SystemDfReport;
8665
8666pub type SystemPruneResponse = SystemPruneReport;
8667
8668/// ImageTreeReport provides results from ImageEngine.Tree()
8669pub type TreeResponse = ImageTreeReport;
8670
8671pub type VersionResponse = ComponentVersion;
8672
8673pub type VolumeCreateResponse = VolumeConfigResponse;
8674
8675/// Volume volume
8676pub type VolumeInspect = Volume;
8677
8678/// Volume list response
8679pub type VolumeList = ListResponse;
8680
8681/// ErrorModel is used in remote connections with podman
8682pub type VolumeNotFound = ErrorModel;
8683
8684/// POST "/volumes/prune"
8685pub type VolumePruneResponse = VolumesPruneReport;