proxmox_api/generated/nodes/node/
lxc.rs

1pub mod vmid;
2#[derive(Debug, Clone)]
3pub struct LxcClient<T> {
4    client: T,
5    path: String,
6}
7impl<T> LxcClient<T>
8where
9    T: crate::client::Client,
10{
11    pub fn new(client: T, parent_path: &str) -> Self {
12        Self {
13            client,
14            path: format!("{}{}", parent_path, "/lxc"),
15        }
16    }
17}
18impl<T> LxcClient<T>
19where
20    T: crate::client::Client,
21{
22    #[doc = "LXC container index (per node)."]
23    #[doc = ""]
24    #[doc = "Only list CTs where you have VM.Audit permission on /vms/\\<vmid\\>."]
25    pub async fn get(&self) -> Result<Vec<GetOutputItems>, T::Error> {
26        let path = self.path.to_string();
27        let optional_vec: Option<Vec<GetOutputItems>> = self.client.get(&path, &()).await?;
28        Ok(optional_vec.unwrap_or_default())
29    }
30}
31impl<T> LxcClient<T>
32where
33    T: crate::client::Client,
34{
35    #[doc = "Create or restore a container."]
36    #[doc = ""]
37    #[doc = "You need 'VM.Allocate' permission on /vms/{vmid} or on the VM pool /pool/{pool}. For restore, it is enough if the user has 'VM.Backup' permission and the VM already exists. You also need 'Datastore.AllocateSpace' permissions on the storage. For privileged containers, 'Sys.Modify' permissions on '/' are required."]
38    pub async fn post(&self, params: PostParams) -> Result<String, T::Error> {
39        let path = self.path.to_string();
40        self.client.post(&path, &params).await
41    }
42}
43impl GetOutputItems {
44    pub fn new(status: Status, vmid: VmidInt) -> Self {
45        Self {
46            status,
47            vmid,
48            cpu: ::std::default::Default::default(),
49            cpus: ::std::default::Default::default(),
50            disk: ::std::default::Default::default(),
51            diskread: ::std::default::Default::default(),
52            diskwrite: ::std::default::Default::default(),
53            lock: ::std::default::Default::default(),
54            maxdisk: ::std::default::Default::default(),
55            maxmem: ::std::default::Default::default(),
56            maxswap: ::std::default::Default::default(),
57            mem: ::std::default::Default::default(),
58            name: ::std::default::Default::default(),
59            netin: ::std::default::Default::default(),
60            netout: ::std::default::Default::default(),
61            pressurecpusome: ::std::default::Default::default(),
62            pressureiofull: ::std::default::Default::default(),
63            pressureiosome: ::std::default::Default::default(),
64            pressurememoryfull: ::std::default::Default::default(),
65            pressurememorysome: ::std::default::Default::default(),
66            tags: ::std::default::Default::default(),
67            template: ::std::default::Default::default(),
68            uptime: ::std::default::Default::default(),
69            additional_properties: ::std::default::Default::default(),
70        }
71    }
72}
73#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
74pub struct GetOutputItems {
75    #[serde(
76        serialize_with = "crate::types::serialize_number_optional",
77        deserialize_with = "crate::types::deserialize_number_optional"
78    )]
79    #[serde(skip_serializing_if = "Option::is_none", default)]
80    #[doc = "Current CPU usage."]
81    #[doc = ""]
82    pub cpu: Option<f64>,
83    #[serde(
84        serialize_with = "crate::types::serialize_number_optional",
85        deserialize_with = "crate::types::deserialize_number_optional"
86    )]
87    #[serde(skip_serializing_if = "Option::is_none", default)]
88    #[doc = "Maximum usable CPUs."]
89    #[doc = ""]
90    pub cpus: Option<f64>,
91    #[serde(
92        serialize_with = "crate::types::serialize_unsigned_int_optional",
93        deserialize_with = "crate::types::deserialize_unsigned_int_optional"
94    )]
95    #[serde(skip_serializing_if = "Option::is_none", default)]
96    #[doc = "Root disk image space-usage in bytes."]
97    #[doc = ""]
98    pub disk: Option<u64>,
99    #[serde(
100        serialize_with = "crate::types::serialize_int_optional",
101        deserialize_with = "crate::types::deserialize_int_optional"
102    )]
103    #[serde(skip_serializing_if = "Option::is_none", default)]
104    #[doc = "The amount of bytes the guest read from it's block devices since the guest was started. (Note: This info is not available for all storage types.)"]
105    #[doc = ""]
106    pub diskread: Option<i64>,
107    #[serde(
108        serialize_with = "crate::types::serialize_int_optional",
109        deserialize_with = "crate::types::deserialize_int_optional"
110    )]
111    #[serde(skip_serializing_if = "Option::is_none", default)]
112    #[doc = "The amount of bytes the guest wrote from it's block devices since the guest was started. (Note: This info is not available for all storage types.)"]
113    #[doc = ""]
114    pub diskwrite: Option<i64>,
115    #[serde(skip_serializing_if = "Option::is_none", default)]
116    #[doc = "The current config lock, if any."]
117    #[doc = ""]
118    pub lock: Option<String>,
119    #[serde(
120        serialize_with = "crate::types::serialize_int_optional",
121        deserialize_with = "crate::types::deserialize_int_optional"
122    )]
123    #[serde(skip_serializing_if = "Option::is_none", default)]
124    #[doc = "Root disk image size in bytes."]
125    #[doc = ""]
126    pub maxdisk: Option<i64>,
127    #[serde(
128        serialize_with = "crate::types::serialize_int_optional",
129        deserialize_with = "crate::types::deserialize_int_optional"
130    )]
131    #[serde(skip_serializing_if = "Option::is_none", default)]
132    #[doc = "Maximum memory in bytes."]
133    #[doc = ""]
134    pub maxmem: Option<i64>,
135    #[serde(
136        serialize_with = "crate::types::serialize_int_optional",
137        deserialize_with = "crate::types::deserialize_int_optional"
138    )]
139    #[serde(skip_serializing_if = "Option::is_none", default)]
140    #[doc = "Maximum SWAP memory in bytes."]
141    #[doc = ""]
142    pub maxswap: Option<i64>,
143    #[serde(
144        serialize_with = "crate::types::serialize_int_optional",
145        deserialize_with = "crate::types::deserialize_int_optional"
146    )]
147    #[serde(skip_serializing_if = "Option::is_none", default)]
148    #[doc = "Currently used memory in bytes."]
149    #[doc = ""]
150    pub mem: Option<i64>,
151    #[serde(skip_serializing_if = "Option::is_none", default)]
152    #[doc = "Container name."]
153    #[doc = ""]
154    pub name: Option<String>,
155    #[serde(
156        serialize_with = "crate::types::serialize_int_optional",
157        deserialize_with = "crate::types::deserialize_int_optional"
158    )]
159    #[serde(skip_serializing_if = "Option::is_none", default)]
160    #[doc = "The amount of traffic in bytes that was sent to the guest over the network since it was started."]
161    #[doc = ""]
162    pub netin: Option<i64>,
163    #[serde(
164        serialize_with = "crate::types::serialize_int_optional",
165        deserialize_with = "crate::types::deserialize_int_optional"
166    )]
167    #[serde(skip_serializing_if = "Option::is_none", default)]
168    #[doc = "The amount of traffic in bytes that was sent from the guest over the network since it was started."]
169    #[doc = ""]
170    pub netout: Option<i64>,
171    #[serde(
172        serialize_with = "crate::types::serialize_number_optional",
173        deserialize_with = "crate::types::deserialize_number_optional"
174    )]
175    #[serde(skip_serializing_if = "Option::is_none", default)]
176    #[doc = "CPU Some pressure stall average over the last 10 seconds."]
177    #[doc = ""]
178    pub pressurecpusome: Option<f64>,
179    #[serde(
180        serialize_with = "crate::types::serialize_number_optional",
181        deserialize_with = "crate::types::deserialize_number_optional"
182    )]
183    #[serde(skip_serializing_if = "Option::is_none", default)]
184    #[doc = "IO Full pressure stall average over the last 10 seconds."]
185    #[doc = ""]
186    pub pressureiofull: Option<f64>,
187    #[serde(
188        serialize_with = "crate::types::serialize_number_optional",
189        deserialize_with = "crate::types::deserialize_number_optional"
190    )]
191    #[serde(skip_serializing_if = "Option::is_none", default)]
192    #[doc = "IO Some pressure stall average over the last 10 seconds."]
193    #[doc = ""]
194    pub pressureiosome: Option<f64>,
195    #[serde(
196        serialize_with = "crate::types::serialize_number_optional",
197        deserialize_with = "crate::types::deserialize_number_optional"
198    )]
199    #[serde(skip_serializing_if = "Option::is_none", default)]
200    #[doc = "Memory Full pressure stall average over the last 10 seconds."]
201    #[doc = ""]
202    pub pressurememoryfull: Option<f64>,
203    #[serde(
204        serialize_with = "crate::types::serialize_number_optional",
205        deserialize_with = "crate::types::deserialize_number_optional"
206    )]
207    #[serde(skip_serializing_if = "Option::is_none", default)]
208    #[doc = "Memory Some pressure stall average over the last 10 seconds."]
209    #[doc = ""]
210    pub pressurememorysome: Option<f64>,
211    #[doc = "LXC Container status."]
212    #[doc = ""]
213    pub status: Status,
214    #[serde(skip_serializing_if = "Option::is_none", default)]
215    #[doc = "The current configured tags, if any."]
216    #[doc = ""]
217    pub tags: Option<String>,
218    #[serde(
219        serialize_with = "crate::types::serialize_bool_optional",
220        deserialize_with = "crate::types::deserialize_bool_optional"
221    )]
222    #[serde(skip_serializing_if = "Option::is_none", default)]
223    #[doc = "Determines if the guest is a template."]
224    #[doc = ""]
225    pub template: Option<bool>,
226    #[serde(
227        serialize_with = "crate::types::serialize_int_optional",
228        deserialize_with = "crate::types::deserialize_int_optional"
229    )]
230    #[serde(skip_serializing_if = "Option::is_none", default)]
231    #[doc = "Uptime in seconds."]
232    #[doc = ""]
233    pub uptime: Option<i64>,
234    #[doc = "The (unique) ID of the VM."]
235    #[doc = ""]
236    pub vmid: VmidInt,
237    #[serde(
238        flatten,
239        default,
240        skip_serializing_if = "::std::collections::HashMap::is_empty"
241    )]
242    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
243}
244impl PostParams {
245    pub fn new(ostemplate: OstemplateStr, vmid: VmidInt) -> Self {
246        Self {
247            ostemplate,
248            vmid,
249            arch: ::std::default::Default::default(),
250            bwlimit: ::std::default::Default::default(),
251            cmode: ::std::default::Default::default(),
252            console: ::std::default::Default::default(),
253            cores: ::std::default::Default::default(),
254            cpulimit: ::std::default::Default::default(),
255            cpuunits: ::std::default::Default::default(),
256            debug: ::std::default::Default::default(),
257            description: ::std::default::Default::default(),
258            devs: ::std::default::Default::default(),
259            entrypoint: ::std::default::Default::default(),
260            env: ::std::default::Default::default(),
261            features: ::std::default::Default::default(),
262            force: ::std::default::Default::default(),
263            ha_managed: ::std::default::Default::default(),
264            hookscript: ::std::default::Default::default(),
265            hostname: ::std::default::Default::default(),
266            ignore_unpack_errors: ::std::default::Default::default(),
267            lock: ::std::default::Default::default(),
268            memory: ::std::default::Default::default(),
269            mps: ::std::default::Default::default(),
270            nameserver: ::std::default::Default::default(),
271            nets: ::std::default::Default::default(),
272            onboot: ::std::default::Default::default(),
273            ostype: ::std::default::Default::default(),
274            password: ::std::default::Default::default(),
275            pool: ::std::default::Default::default(),
276            protection: ::std::default::Default::default(),
277            restore: ::std::default::Default::default(),
278            rootfs: ::std::default::Default::default(),
279            searchdomain: ::std::default::Default::default(),
280            ssh_public_keys: ::std::default::Default::default(),
281            start: ::std::default::Default::default(),
282            startup: ::std::default::Default::default(),
283            storage: ::std::default::Default::default(),
284            swap: ::std::default::Default::default(),
285            tags: ::std::default::Default::default(),
286            template: ::std::default::Default::default(),
287            timezone: ::std::default::Default::default(),
288            tty: ::std::default::Default::default(),
289            unique: ::std::default::Default::default(),
290            unprivileged: ::std::default::Default::default(),
291            unuseds: ::std::default::Default::default(),
292            additional_properties: ::std::default::Default::default(),
293        }
294    }
295}
296#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
297pub struct PostParams {
298    #[serde(skip_serializing_if = "Option::is_none", default)]
299    #[doc = "OS architecture type."]
300    #[doc = ""]
301    pub arch: Option<Arch>,
302    #[serde(skip_serializing_if = "Option::is_none", default)]
303    #[doc = "Override I/O bandwidth limit (in KiB/s)."]
304    #[doc = ""]
305    pub bwlimit: Option<BwlimitNum>,
306    #[serde(skip_serializing_if = "Option::is_none", default)]
307    #[doc = "Console mode. By default, the console command tries to open a connection to one of the available tty devices. By setting cmode to 'console' it tries to attach to /dev/console instead. If you set cmode to 'shell', it simply invokes a shell inside the container (no login)."]
308    #[doc = ""]
309    pub cmode: Option<Cmode>,
310    #[serde(
311        serialize_with = "crate::types::serialize_bool_optional",
312        deserialize_with = "crate::types::deserialize_bool_optional"
313    )]
314    #[serde(skip_serializing_if = "Option::is_none", default)]
315    #[doc = "Attach a console device (/dev/console) to the container."]
316    #[doc = ""]
317    pub console: Option<bool>,
318    #[serde(skip_serializing_if = "Option::is_none", default)]
319    #[doc = "The number of cores assigned to the container. A container can use all available cores by default."]
320    #[doc = ""]
321    pub cores: Option<CoresInt>,
322    #[serde(skip_serializing_if = "Option::is_none", default)]
323    #[doc = "Limit of CPU usage."]
324    #[doc = ""]
325    #[doc = "NOTE: If the computer has 2 CPUs, it has a total of '2' CPU time. Value '0' indicates no CPU limit."]
326    #[doc = ""]
327    pub cpulimit: Option<CpulimitNum>,
328    #[serde(skip_serializing_if = "Option::is_none", default)]
329    #[doc = "CPU weight for a container, will be clamped to \\\\[1, 10000\\\\] in cgroup v2."]
330    #[doc = ""]
331    #[doc = "CPU weight for a container. Argument is used in the kernel fair scheduler. The larger the number is, the more CPU time this container gets. Number is relative to the weights of all the other running guests."]
332    #[doc = ""]
333    pub cpuunits: Option<CpuunitsInt>,
334    #[serde(
335        serialize_with = "crate::types::serialize_bool_optional",
336        deserialize_with = "crate::types::deserialize_bool_optional"
337    )]
338    #[serde(skip_serializing_if = "Option::is_none", default)]
339    #[doc = "Try to be more verbose. For now this only enables debug log-level on start."]
340    #[doc = ""]
341    pub debug: Option<bool>,
342    #[serde(skip_serializing_if = "Option::is_none", default)]
343    #[doc = "Description for the Container. Shown in the web-interface CT's summary. This is saved as comment inside the configuration file."]
344    #[doc = ""]
345    pub description: Option<DescriptionStr>,
346    #[serde(rename = "dev[n]")]
347    #[serde(
348        serialize_with = "crate::types::serialize_multi::<NumberedDevs, _>",
349        deserialize_with = "crate::types::deserialize_multi::<NumberedDevs, _>"
350    )]
351    #[serde(skip_serializing_if = "::std::collections::HashMap::is_empty", default)]
352    #[serde(flatten)]
353    #[doc = "Device to pass through to the container"]
354    #[doc = ""]
355    pub devs: ::std::collections::HashMap<u32, String>,
356    #[serde(skip_serializing_if = "Option::is_none", default)]
357    #[doc = "Command to run as init, optionally with arguments; may start with an absolute path, relative path, or a binary in $PATH."]
358    #[doc = ""]
359    pub entrypoint: Option<EntrypointStr>,
360    #[serde(skip_serializing_if = "Option::is_none", default)]
361    #[doc = "The container runtime environment as NUL-separated list. Replaces any lxc.environment.runtime entries in the config."]
362    #[doc = ""]
363    pub env: Option<EnvStr>,
364    #[serde(skip_serializing_if = "Option::is_none", default)]
365    #[doc = "Allow containers access to advanced features."]
366    #[doc = ""]
367    pub features: Option<String>,
368    #[serde(
369        serialize_with = "crate::types::serialize_bool_optional",
370        deserialize_with = "crate::types::deserialize_bool_optional"
371    )]
372    #[serde(skip_serializing_if = "Option::is_none", default)]
373    #[doc = "Allow to overwrite existing container."]
374    #[doc = ""]
375    pub force: Option<bool>,
376    #[serde(rename = "ha-managed")]
377    #[serde(
378        serialize_with = "crate::types::serialize_bool_optional",
379        deserialize_with = "crate::types::deserialize_bool_optional"
380    )]
381    #[serde(skip_serializing_if = "Option::is_none", default)]
382    #[doc = "Add the CT as a HA resource after it was created."]
383    #[doc = ""]
384    pub ha_managed: Option<bool>,
385    #[serde(skip_serializing_if = "Option::is_none", default)]
386    #[doc = "Script that will be executed during various steps in the containers lifetime."]
387    #[doc = ""]
388    pub hookscript: Option<String>,
389    #[serde(skip_serializing_if = "Option::is_none", default)]
390    #[doc = "Set a host name for the container."]
391    #[doc = ""]
392    pub hostname: Option<HostnameStr>,
393    #[serde(rename = "ignore-unpack-errors")]
394    #[serde(
395        serialize_with = "crate::types::serialize_bool_optional",
396        deserialize_with = "crate::types::deserialize_bool_optional"
397    )]
398    #[serde(skip_serializing_if = "Option::is_none", default)]
399    #[doc = "Ignore errors when extracting the template."]
400    #[doc = ""]
401    pub ignore_unpack_errors: Option<bool>,
402    #[serde(skip_serializing_if = "Option::is_none", default)]
403    #[doc = "Lock/unlock the container."]
404    #[doc = ""]
405    pub lock: Option<Lock>,
406    #[serde(skip_serializing_if = "Option::is_none", default)]
407    #[doc = "Amount of RAM for the container in MB."]
408    #[doc = ""]
409    pub memory: Option<MemoryInt>,
410    #[serde(rename = "mp[n]")]
411    #[serde(
412        serialize_with = "crate::types::serialize_multi::<NumberedMps, _>",
413        deserialize_with = "crate::types::deserialize_multi::<NumberedMps, _>"
414    )]
415    #[serde(skip_serializing_if = "::std::collections::HashMap::is_empty", default)]
416    #[serde(flatten)]
417    #[doc = "Use volume as container mount point. Use the special syntax STORAGE_ID:SIZE_IN_GiB to allocate a new volume."]
418    #[doc = ""]
419    pub mps: ::std::collections::HashMap<u32, String>,
420    #[serde(skip_serializing_if = "Option::is_none", default)]
421    #[doc = "Sets DNS server IP address for a container. Create will automatically use the setting from the host if you neither set searchdomain nor nameserver."]
422    #[doc = ""]
423    pub nameserver: Option<String>,
424    #[serde(rename = "net[n]")]
425    #[serde(
426        serialize_with = "crate::types::serialize_multi::<NumberedNets, _>",
427        deserialize_with = "crate::types::deserialize_multi::<NumberedNets, _>"
428    )]
429    #[serde(skip_serializing_if = "::std::collections::HashMap::is_empty", default)]
430    #[serde(flatten)]
431    #[doc = "Specifies network interfaces for the container."]
432    #[doc = ""]
433    pub nets: ::std::collections::HashMap<u32, String>,
434    #[serde(
435        serialize_with = "crate::types::serialize_bool_optional",
436        deserialize_with = "crate::types::deserialize_bool_optional"
437    )]
438    #[serde(skip_serializing_if = "Option::is_none", default)]
439    #[doc = "Specifies whether a container will be started during system bootup."]
440    #[doc = ""]
441    pub onboot: Option<bool>,
442    #[doc = "The OS template or backup file."]
443    #[doc = ""]
444    pub ostemplate: OstemplateStr,
445    #[serde(skip_serializing_if = "Option::is_none", default)]
446    #[doc = "OS type. This is used to setup configuration inside the container, and corresponds to lxc setup scripts in /usr/share/lxc/config/\\\\<ostype\\\\>.common.conf. Value 'unmanaged' can be used to skip and OS specific setup."]
447    #[doc = ""]
448    pub ostype: Option<Ostype>,
449    #[serde(skip_serializing_if = "Option::is_none", default)]
450    #[doc = "Sets root password inside container."]
451    #[doc = ""]
452    pub password: Option<PasswordStr>,
453    #[serde(skip_serializing_if = "Option::is_none", default)]
454    #[doc = "Add the VM to the specified pool."]
455    #[doc = ""]
456    pub pool: Option<String>,
457    #[serde(
458        serialize_with = "crate::types::serialize_bool_optional",
459        deserialize_with = "crate::types::deserialize_bool_optional"
460    )]
461    #[serde(skip_serializing_if = "Option::is_none", default)]
462    #[doc = "Sets the protection flag of the container. This will prevent the CT or CT's disk remove/update operation."]
463    #[doc = ""]
464    pub protection: Option<bool>,
465    #[serde(
466        serialize_with = "crate::types::serialize_bool_optional",
467        deserialize_with = "crate::types::deserialize_bool_optional"
468    )]
469    #[serde(skip_serializing_if = "Option::is_none", default)]
470    #[doc = "Mark this as restore task."]
471    #[doc = ""]
472    pub restore: Option<bool>,
473    #[serde(skip_serializing_if = "Option::is_none", default)]
474    #[doc = "Use volume as container root."]
475    #[doc = ""]
476    pub rootfs: Option<String>,
477    #[serde(skip_serializing_if = "Option::is_none", default)]
478    #[doc = "Sets DNS search domains for a container. Create will automatically use the setting from the host if you neither set searchdomain nor nameserver."]
479    #[doc = ""]
480    pub searchdomain: Option<String>,
481    #[serde(rename = "ssh-public-keys")]
482    #[serde(skip_serializing_if = "Option::is_none", default)]
483    #[doc = "Setup public SSH keys (one key per line, OpenSSH format)."]
484    #[doc = ""]
485    pub ssh_public_keys: Option<String>,
486    #[serde(
487        serialize_with = "crate::types::serialize_bool_optional",
488        deserialize_with = "crate::types::deserialize_bool_optional"
489    )]
490    #[serde(skip_serializing_if = "Option::is_none", default)]
491    #[doc = "Start the CT after its creation finished successfully."]
492    #[doc = ""]
493    pub start: Option<bool>,
494    #[serde(skip_serializing_if = "Option::is_none", default)]
495    #[doc = "Startup and shutdown behavior. Order is a non-negative number defining the general startup order. Shutdown in done with reverse ordering. Additionally you can set the 'up' or 'down' delay in seconds, which specifies a delay to wait before the next VM is started or stopped."]
496    #[doc = ""]
497    pub startup: Option<String>,
498    #[serde(skip_serializing_if = "Option::is_none", default)]
499    #[doc = "Default Storage."]
500    #[doc = ""]
501    pub storage: Option<String>,
502    #[serde(skip_serializing_if = "Option::is_none", default)]
503    #[doc = "Amount of SWAP for the container in MB."]
504    #[doc = ""]
505    pub swap: Option<SwapInt>,
506    #[serde(skip_serializing_if = "Option::is_none", default)]
507    #[doc = "Tags of the Container. This is only meta information."]
508    #[doc = ""]
509    pub tags: Option<String>,
510    #[serde(
511        serialize_with = "crate::types::serialize_bool_optional",
512        deserialize_with = "crate::types::deserialize_bool_optional"
513    )]
514    #[serde(skip_serializing_if = "Option::is_none", default)]
515    #[doc = "Enable/disable Template."]
516    #[doc = ""]
517    pub template: Option<bool>,
518    #[serde(skip_serializing_if = "Option::is_none", default)]
519    #[doc = "Time zone to use in the container. If option isn't set, then nothing will be done. Can be set to 'host' to match the host time zone, or an arbitrary time zone option from /usr/share/zoneinfo/zone.tab"]
520    #[doc = ""]
521    pub timezone: Option<String>,
522    #[serde(skip_serializing_if = "Option::is_none", default)]
523    #[doc = "Specify the number of tty available to the container"]
524    #[doc = ""]
525    pub tty: Option<TtyInt>,
526    #[serde(
527        serialize_with = "crate::types::serialize_bool_optional",
528        deserialize_with = "crate::types::deserialize_bool_optional"
529    )]
530    #[serde(skip_serializing_if = "Option::is_none", default)]
531    #[doc = "Assign a unique random ethernet address."]
532    #[doc = ""]
533    pub unique: Option<bool>,
534    #[serde(
535        serialize_with = "crate::types::serialize_bool_optional",
536        deserialize_with = "crate::types::deserialize_bool_optional"
537    )]
538    #[serde(skip_serializing_if = "Option::is_none", default)]
539    #[doc = "Makes the container run as unprivileged user. For creation, the default is 1. For restore, the default is the value from the backup. (Should not be modified manually.)"]
540    #[doc = ""]
541    pub unprivileged: Option<bool>,
542    #[serde(rename = "unused[n]")]
543    #[serde(
544        serialize_with = "crate::types::serialize_multi::<NumberedUnuseds, _>",
545        deserialize_with = "crate::types::deserialize_multi::<NumberedUnuseds, _>"
546    )]
547    #[serde(skip_serializing_if = "::std::collections::HashMap::is_empty", default)]
548    #[serde(flatten)]
549    #[doc = "Reference to unused volumes. This is used internally, and should not be modified manually."]
550    #[doc = ""]
551    pub unuseds: ::std::collections::HashMap<u32, String>,
552    #[doc = "The (unique) ID of the VM."]
553    #[doc = ""]
554    pub vmid: VmidInt,
555    #[serde(
556        flatten,
557        deserialize_with = "crate::types::multi::deserialize_additional_data::<'_, PostParams, _, _>"
558    )]
559    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
560}
561impl crate::types::multi::Test for PostParams {
562    fn test_fn() -> fn(&str) -> bool {
563        fn the_test(input: &str) -> bool {
564            let array = [
565                <NumberedDevs as crate::types::multi::NumberedItems>::key_matches
566                    as fn(&str) -> bool,
567                <NumberedMps as crate::types::multi::NumberedItems>::key_matches
568                    as fn(&str) -> bool,
569                <NumberedNets as crate::types::multi::NumberedItems>::key_matches
570                    as fn(&str) -> bool,
571                <NumberedUnuseds as crate::types::multi::NumberedItems>::key_matches
572                    as fn(&str) -> bool,
573            ];
574            array.iter().any(|f| f(input))
575        }
576        the_test as _
577    }
578}
579#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq, Default)]
580#[doc = "OS architecture type."]
581#[doc = ""]
582pub enum Arch {
583    #[serde(rename = "amd64")]
584    #[default]
585    Amd64,
586    #[serde(rename = "arm64")]
587    Arm64,
588    #[serde(rename = "armhf")]
589    Armhf,
590    #[serde(rename = "i386")]
591    I386,
592    #[serde(rename = "riscv32")]
593    Riscv32,
594    #[serde(rename = "riscv64")]
595    Riscv64,
596}
597impl TryFrom<&str> for Arch {
598    type Error = String;
599    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
600        match value {
601            "amd64" => Ok(Self::Amd64),
602            "arm64" => Ok(Self::Arm64),
603            "armhf" => Ok(Self::Armhf),
604            "i386" => Ok(Self::I386),
605            "riscv32" => Ok(Self::Riscv32),
606            "riscv64" => Ok(Self::Riscv64),
607            v => Err(format!("Unknown variant {v}")),
608        }
609    }
610}
611#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq, Default)]
612#[doc = "Console mode. By default, the console command tries to open a connection to one of the available tty devices. By setting cmode to 'console' it tries to attach to /dev/console instead. If you set cmode to 'shell', it simply invokes a shell inside the container (no login)."]
613#[doc = ""]
614pub enum Cmode {
615    #[serde(rename = "console")]
616    Console,
617    #[serde(rename = "shell")]
618    Shell,
619    #[serde(rename = "tty")]
620    #[default]
621    Tty,
622}
623impl TryFrom<&str> for Cmode {
624    type Error = String;
625    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
626        match value {
627            "console" => Ok(Self::Console),
628            "shell" => Ok(Self::Shell),
629            "tty" => Ok(Self::Tty),
630            v => Err(format!("Unknown variant {v}")),
631        }
632    }
633}
634#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
635#[doc = "Lock/unlock the container."]
636#[doc = ""]
637pub enum Lock {
638    #[serde(rename = "backup")]
639    Backup,
640    #[serde(rename = "create")]
641    Create,
642    #[serde(rename = "destroyed")]
643    Destroyed,
644    #[serde(rename = "disk")]
645    Disk,
646    #[serde(rename = "fstrim")]
647    Fstrim,
648    #[serde(rename = "migrate")]
649    Migrate,
650    #[serde(rename = "mounted")]
651    Mounted,
652    #[serde(rename = "rollback")]
653    Rollback,
654    #[serde(rename = "snapshot")]
655    Snapshot,
656    #[serde(rename = "snapshot-delete")]
657    SnapshotDelete,
658}
659impl TryFrom<&str> for Lock {
660    type Error = String;
661    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
662        match value {
663            "backup" => Ok(Self::Backup),
664            "create" => Ok(Self::Create),
665            "destroyed" => Ok(Self::Destroyed),
666            "disk" => Ok(Self::Disk),
667            "fstrim" => Ok(Self::Fstrim),
668            "migrate" => Ok(Self::Migrate),
669            "mounted" => Ok(Self::Mounted),
670            "rollback" => Ok(Self::Rollback),
671            "snapshot" => Ok(Self::Snapshot),
672            "snapshot-delete" => Ok(Self::SnapshotDelete),
673            v => Err(format!("Unknown variant {v}")),
674        }
675    }
676}
677#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
678#[doc = "OS type. This is used to setup configuration inside the container, and corresponds to lxc setup scripts in /usr/share/lxc/config/\\<ostype\\>.common.conf. Value 'unmanaged' can be used to skip and OS specific setup."]
679#[doc = ""]
680pub enum Ostype {
681    #[serde(rename = "alpine")]
682    Alpine,
683    #[serde(rename = "archlinux")]
684    Archlinux,
685    #[serde(rename = "centos")]
686    Centos,
687    #[serde(rename = "debian")]
688    Debian,
689    #[serde(rename = "devuan")]
690    Devuan,
691    #[serde(rename = "fedora")]
692    Fedora,
693    #[serde(rename = "gentoo")]
694    Gentoo,
695    #[serde(rename = "nixos")]
696    Nixos,
697    #[serde(rename = "opensuse")]
698    Opensuse,
699    #[serde(rename = "ubuntu")]
700    Ubuntu,
701    #[serde(rename = "unmanaged")]
702    Unmanaged,
703}
704impl TryFrom<&str> for Ostype {
705    type Error = String;
706    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
707        match value {
708            "alpine" => Ok(Self::Alpine),
709            "archlinux" => Ok(Self::Archlinux),
710            "centos" => Ok(Self::Centos),
711            "debian" => Ok(Self::Debian),
712            "devuan" => Ok(Self::Devuan),
713            "fedora" => Ok(Self::Fedora),
714            "gentoo" => Ok(Self::Gentoo),
715            "nixos" => Ok(Self::Nixos),
716            "opensuse" => Ok(Self::Opensuse),
717            "ubuntu" => Ok(Self::Ubuntu),
718            "unmanaged" => Ok(Self::Unmanaged),
719            v => Err(format!("Unknown variant {v}")),
720        }
721    }
722}
723#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
724#[doc = "LXC Container status."]
725#[doc = ""]
726pub enum Status {
727    #[serde(rename = "running")]
728    Running,
729    #[serde(rename = "stopped")]
730    Stopped,
731}
732impl TryFrom<&str> for Status {
733    type Error = String;
734    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
735        match value {
736            "running" => Ok(Self::Running),
737            "stopped" => Ok(Self::Stopped),
738            v => Err(format!("Unknown variant {v}")),
739        }
740    }
741}
742#[derive(Default)]
743struct NumberedDevs;
744impl crate::types::multi::NumberedItems for NumberedDevs {
745    type Item = String;
746    const PREFIX: &'static str = "dev";
747}
748#[derive(Default)]
749struct NumberedMps;
750impl crate::types::multi::NumberedItems for NumberedMps {
751    type Item = String;
752    const PREFIX: &'static str = "mp";
753}
754#[derive(Default)]
755struct NumberedNets;
756impl crate::types::multi::NumberedItems for NumberedNets {
757    type Item = String;
758    const PREFIX: &'static str = "net";
759}
760#[derive(Default)]
761struct NumberedUnuseds;
762impl crate::types::multi::NumberedItems for NumberedUnuseds {
763    type Item = String;
764    const PREFIX: &'static str = "unused";
765}
766#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
767pub struct CoresInt(i128);
768impl crate::types::bounded_integer::BoundedInteger for CoresInt {
769    const MIN: Option<i128> = Some(1i128);
770    const MAX: Option<i128> = Some(8192i128);
771    const DEFAULT: Option<i128> = None::<i128>;
772    const TYPE_DESCRIPTION: &'static str = "an integer between 1 and 8192";
773    fn get(&self) -> i128 {
774        self.0
775    }
776    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
777        Self::validate(value)?;
778        Ok(Self(value))
779    }
780}
781impl std::convert::TryFrom<i128> for CoresInt {
782    type Error = crate::types::bounded_integer::BoundedIntegerError;
783    fn try_from(value: i128) -> Result<Self, Self::Error> {
784        crate::types::bounded_integer::BoundedInteger::new(value)
785    }
786}
787impl ::serde::Serialize for CoresInt {
788    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
789    where
790        S: ::serde::Serializer,
791    {
792        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
793    }
794}
795impl<'de> ::serde::Deserialize<'de> for CoresInt {
796    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
797    where
798        D: ::serde::Deserializer<'de>,
799    {
800        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
801    }
802}
803#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
804pub struct CpuunitsInt(i128);
805impl crate::types::bounded_integer::BoundedInteger for CpuunitsInt {
806    const MIN: Option<i128> = Some(0i128);
807    const MAX: Option<i128> = Some(500000i128);
808    const DEFAULT: Option<i128> = None::<i128>;
809    const TYPE_DESCRIPTION: &'static str = "an integer between 0 and 500000";
810    fn get(&self) -> i128 {
811        self.0
812    }
813    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
814        Self::validate(value)?;
815        Ok(Self(value))
816    }
817}
818impl std::convert::TryFrom<i128> for CpuunitsInt {
819    type Error = crate::types::bounded_integer::BoundedIntegerError;
820    fn try_from(value: i128) -> Result<Self, Self::Error> {
821        crate::types::bounded_integer::BoundedInteger::new(value)
822    }
823}
824impl ::serde::Serialize for CpuunitsInt {
825    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
826    where
827        S: ::serde::Serializer,
828    {
829        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
830    }
831}
832impl<'de> ::serde::Deserialize<'de> for CpuunitsInt {
833    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
834    where
835        D: ::serde::Deserializer<'de>,
836    {
837        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
838    }
839}
840#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
841pub struct MemoryInt(i128);
842impl crate::types::bounded_integer::BoundedInteger for MemoryInt {
843    const MIN: Option<i128> = Some(16i128);
844    const MAX: Option<i128> = None::<i128>;
845    const DEFAULT: Option<i128> = Some(512i128);
846    const TYPE_DESCRIPTION: &'static str = "an integer greater than or equal to 16";
847    fn get(&self) -> i128 {
848        self.0
849    }
850    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
851        Self::validate(value)?;
852        Ok(Self(value))
853    }
854}
855impl std::convert::TryFrom<i128> for MemoryInt {
856    type Error = crate::types::bounded_integer::BoundedIntegerError;
857    fn try_from(value: i128) -> Result<Self, Self::Error> {
858        crate::types::bounded_integer::BoundedInteger::new(value)
859    }
860}
861impl ::serde::Serialize for MemoryInt {
862    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
863    where
864        S: ::serde::Serializer,
865    {
866        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
867    }
868}
869impl<'de> ::serde::Deserialize<'de> for MemoryInt {
870    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
871    where
872        D: ::serde::Deserializer<'de>,
873    {
874        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
875    }
876}
877#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
878pub struct SwapInt(i128);
879impl crate::types::bounded_integer::BoundedInteger for SwapInt {
880    const MIN: Option<i128> = Some(0i128);
881    const MAX: Option<i128> = None::<i128>;
882    const DEFAULT: Option<i128> = Some(512i128);
883    const TYPE_DESCRIPTION: &'static str = "an integer greater than or equal to 0";
884    fn get(&self) -> i128 {
885        self.0
886    }
887    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
888        Self::validate(value)?;
889        Ok(Self(value))
890    }
891}
892impl std::convert::TryFrom<i128> for SwapInt {
893    type Error = crate::types::bounded_integer::BoundedIntegerError;
894    fn try_from(value: i128) -> Result<Self, Self::Error> {
895        crate::types::bounded_integer::BoundedInteger::new(value)
896    }
897}
898impl ::serde::Serialize for SwapInt {
899    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
900    where
901        S: ::serde::Serializer,
902    {
903        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
904    }
905}
906impl<'de> ::serde::Deserialize<'de> for SwapInt {
907    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
908    where
909        D: ::serde::Deserializer<'de>,
910    {
911        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
912    }
913}
914#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
915pub struct TtyInt(i128);
916impl crate::types::bounded_integer::BoundedInteger for TtyInt {
917    const MIN: Option<i128> = Some(0i128);
918    const MAX: Option<i128> = Some(6i128);
919    const DEFAULT: Option<i128> = Some(2i128);
920    const TYPE_DESCRIPTION: &'static str = "an integer between 0 and 6";
921    fn get(&self) -> i128 {
922        self.0
923    }
924    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
925        Self::validate(value)?;
926        Ok(Self(value))
927    }
928}
929impl std::convert::TryFrom<i128> for TtyInt {
930    type Error = crate::types::bounded_integer::BoundedIntegerError;
931    fn try_from(value: i128) -> Result<Self, Self::Error> {
932        crate::types::bounded_integer::BoundedInteger::new(value)
933    }
934}
935impl ::serde::Serialize for TtyInt {
936    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
937    where
938        S: ::serde::Serializer,
939    {
940        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
941    }
942}
943impl<'de> ::serde::Deserialize<'de> for TtyInt {
944    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
945    where
946        D: ::serde::Deserializer<'de>,
947    {
948        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
949    }
950}
951#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
952pub struct VmidInt(i128);
953impl crate::types::bounded_integer::BoundedInteger for VmidInt {
954    const MIN: Option<i128> = Some(100i128);
955    const MAX: Option<i128> = Some(999999999i128);
956    const DEFAULT: Option<i128> = None::<i128>;
957    const TYPE_DESCRIPTION: &'static str = "an integer between 100 and 999999999";
958    fn get(&self) -> i128 {
959        self.0
960    }
961    fn new(value: i128) -> Result<Self, crate::types::bounded_integer::BoundedIntegerError> {
962        Self::validate(value)?;
963        Ok(Self(value))
964    }
965}
966impl std::convert::TryFrom<i128> for VmidInt {
967    type Error = crate::types::bounded_integer::BoundedIntegerError;
968    fn try_from(value: i128) -> Result<Self, Self::Error> {
969        crate::types::bounded_integer::BoundedInteger::new(value)
970    }
971}
972impl ::serde::Serialize for VmidInt {
973    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
974    where
975        S: ::serde::Serializer,
976    {
977        crate::types::bounded_integer::serialize_bounded_integer(self, serializer)
978    }
979}
980impl<'de> ::serde::Deserialize<'de> for VmidInt {
981    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
982    where
983        D: ::serde::Deserializer<'de>,
984    {
985        crate::types::bounded_integer::deserialize_bounded_integer(deserializer)
986    }
987}
988#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
989pub struct BwlimitNum(f64);
990impl crate::types::bounded_number::BoundedNumber for BwlimitNum {
991    const MIN: Option<f64> = Some(0f64);
992    const MAX: Option<f64> = None::<f64>;
993    const DEFAULT: Option<f64> = None::<f64>;
994    const TYPE_DESCRIPTION: &'static str = "an number greater than or equal to 0";
995    fn get(&self) -> f64 {
996        self.0
997    }
998    fn new(value: f64) -> Result<Self, crate::types::bounded_number::BoundedNumberError> {
999        Self::validate(value)?;
1000        Ok(Self(value))
1001    }
1002}
1003impl std::convert::TryFrom<f64> for BwlimitNum {
1004    type Error = crate::types::bounded_number::BoundedNumberError;
1005    fn try_from(value: f64) -> Result<Self, Self::Error> {
1006        crate::types::bounded_number::BoundedNumber::new(value)
1007    }
1008}
1009impl std::convert::TryFrom<f32> for BwlimitNum {
1010    type Error = crate::types::bounded_number::BoundedNumberError;
1011    fn try_from(value: f32) -> Result<Self, Self::Error> {
1012        crate::types::bounded_number::BoundedNumber::new(value as f64)
1013    }
1014}
1015impl std::convert::TryFrom<i32> for BwlimitNum {
1016    type Error = crate::types::bounded_number::BoundedNumberError;
1017    fn try_from(value: i32) -> Result<Self, Self::Error> {
1018        crate::types::bounded_number::BoundedNumber::new(value as f64)
1019    }
1020}
1021impl std::convert::TryFrom<i64> for BwlimitNum {
1022    type Error = crate::types::bounded_number::BoundedNumberError;
1023    fn try_from(value: i64) -> Result<Self, Self::Error> {
1024        crate::types::bounded_number::BoundedNumber::new(value as f64)
1025    }
1026}
1027impl ::serde::Serialize for BwlimitNum {
1028    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1029    where
1030        S: ::serde::Serializer,
1031    {
1032        crate::types::bounded_number::serialize_bounded_number(self, serializer)
1033    }
1034}
1035impl<'de> ::serde::Deserialize<'de> for BwlimitNum {
1036    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1037    where
1038        D: ::serde::Deserializer<'de>,
1039    {
1040        crate::types::bounded_number::deserialize_bounded_number(deserializer)
1041    }
1042}
1043#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
1044pub struct CpulimitNum(f64);
1045impl crate::types::bounded_number::BoundedNumber for CpulimitNum {
1046    const MIN: Option<f64> = Some(0f64);
1047    const MAX: Option<f64> = Some(8192f64);
1048    const DEFAULT: Option<f64> = Some(0f64);
1049    const TYPE_DESCRIPTION: &'static str = "an number between 0 and 8192";
1050    fn get(&self) -> f64 {
1051        self.0
1052    }
1053    fn new(value: f64) -> Result<Self, crate::types::bounded_number::BoundedNumberError> {
1054        Self::validate(value)?;
1055        Ok(Self(value))
1056    }
1057}
1058impl std::convert::TryFrom<f64> for CpulimitNum {
1059    type Error = crate::types::bounded_number::BoundedNumberError;
1060    fn try_from(value: f64) -> Result<Self, Self::Error> {
1061        crate::types::bounded_number::BoundedNumber::new(value)
1062    }
1063}
1064impl std::convert::TryFrom<f32> for CpulimitNum {
1065    type Error = crate::types::bounded_number::BoundedNumberError;
1066    fn try_from(value: f32) -> Result<Self, Self::Error> {
1067        crate::types::bounded_number::BoundedNumber::new(value as f64)
1068    }
1069}
1070impl std::convert::TryFrom<i32> for CpulimitNum {
1071    type Error = crate::types::bounded_number::BoundedNumberError;
1072    fn try_from(value: i32) -> Result<Self, Self::Error> {
1073        crate::types::bounded_number::BoundedNumber::new(value as f64)
1074    }
1075}
1076impl std::convert::TryFrom<i64> for CpulimitNum {
1077    type Error = crate::types::bounded_number::BoundedNumberError;
1078    fn try_from(value: i64) -> Result<Self, Self::Error> {
1079        crate::types::bounded_number::BoundedNumber::new(value as f64)
1080    }
1081}
1082impl ::serde::Serialize for CpulimitNum {
1083    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1084    where
1085        S: ::serde::Serializer,
1086    {
1087        crate::types::bounded_number::serialize_bounded_number(self, serializer)
1088    }
1089}
1090impl<'de> ::serde::Deserialize<'de> for CpulimitNum {
1091    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1092    where
1093        D: ::serde::Deserializer<'de>,
1094    {
1095        crate::types::bounded_number::deserialize_bounded_number(deserializer)
1096    }
1097}
1098#[derive(Debug, Clone, PartialEq, PartialOrd)]
1099pub struct DescriptionStr {
1100    value: String,
1101}
1102impl crate::types::bounded_string::BoundedString for DescriptionStr {
1103    const MIN_LENGTH: Option<usize> = None::<usize>;
1104    const MAX_LENGTH: Option<usize> = Some(8192usize);
1105    const DEFAULT: Option<&'static str> = None::<&'static str>;
1106    const PATTERN: Option<&'static str> = None::<&'static str>;
1107    const TYPE_DESCRIPTION: &'static str = "a string with length at most 8192";
1108    fn get_value(&self) -> &str {
1109        &self.value
1110    }
1111    fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
1112        Self::validate(&value)?;
1113        Ok(Self { value })
1114    }
1115}
1116impl std::convert::TryFrom<String> for DescriptionStr {
1117    type Error = crate::types::bounded_string::BoundedStringError;
1118    fn try_from(value: String) -> Result<Self, Self::Error> {
1119        crate::types::bounded_string::BoundedString::new(value)
1120    }
1121}
1122impl ::serde::Serialize for DescriptionStr {
1123    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1124    where
1125        S: ::serde::Serializer,
1126    {
1127        crate::types::bounded_string::serialize_bounded_string(self, serializer)
1128    }
1129}
1130impl<'de> ::serde::Deserialize<'de> for DescriptionStr {
1131    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1132    where
1133        D: ::serde::Deserializer<'de>,
1134    {
1135        crate::types::bounded_string::deserialize_bounded_string(deserializer)
1136    }
1137}
1138#[derive(Debug, Clone, PartialEq, PartialOrd)]
1139pub struct EntrypointStr {
1140    value: String,
1141}
1142impl crate::types::bounded_string::BoundedString for EntrypointStr {
1143    const MIN_LENGTH: Option<usize> = None::<usize>;
1144    const MAX_LENGTH: Option<usize> = None::<usize>;
1145    const DEFAULT: Option<&'static str> = Some("/sbin/init");
1146    const PATTERN: Option<&'static str> = Some("(?^:[^\\x00-\\x08\\x10-\\x1F\\x7F]+)");
1147    const TYPE_DESCRIPTION: &'static str =
1148        "a string with pattern r\"(?^:[^\\x00-\\x08\\x10-\\x1F\\x7F]+)\" and no length constraints";
1149    fn get_value(&self) -> &str {
1150        &self.value
1151    }
1152    fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
1153        Self::validate(&value)?;
1154        Ok(Self { value })
1155    }
1156}
1157impl std::convert::TryFrom<String> for EntrypointStr {
1158    type Error = crate::types::bounded_string::BoundedStringError;
1159    fn try_from(value: String) -> Result<Self, Self::Error> {
1160        crate::types::bounded_string::BoundedString::new(value)
1161    }
1162}
1163impl ::serde::Serialize for EntrypointStr {
1164    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1165    where
1166        S: ::serde::Serializer,
1167    {
1168        crate::types::bounded_string::serialize_bounded_string(self, serializer)
1169    }
1170}
1171impl<'de> ::serde::Deserialize<'de> for EntrypointStr {
1172    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1173    where
1174        D: ::serde::Deserializer<'de>,
1175    {
1176        crate::types::bounded_string::deserialize_bounded_string(deserializer)
1177    }
1178}
1179#[derive(Debug, Clone, PartialEq, PartialOrd)]
1180pub struct EnvStr {
1181    value: String,
1182}
1183impl crate::types::bounded_string::BoundedString for EnvStr {
1184    const MIN_LENGTH: Option<usize> = None::<usize>;
1185    const MAX_LENGTH: Option<usize> = None::<usize>;
1186    const DEFAULT: Option<&'static str> = None::<&'static str>;
1187    const PATTERN: Option<&'static str> = Some(
1188        "(?^:(?:\\w+=[^\\x00-\\x08\\x10-\\x1F\\x7F]*)(?:\\0\\w+=[^\\x00-\\x08\\x10-\\x1F\\x7F]*)*)",
1189    );
1190    const TYPE_DESCRIPTION: &'static str = "a string with pattern r\"(?^:(?:\\w+=[^\\x00-\\x08\\x10-\\x1F\\x7F]*)(?:\\0\\w+=[^\\x00-\\x08\\x10-\\x1F\\x7F]*)*)\" and no length constraints";
1191    fn get_value(&self) -> &str {
1192        &self.value
1193    }
1194    fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
1195        Self::validate(&value)?;
1196        Ok(Self { value })
1197    }
1198}
1199impl std::convert::TryFrom<String> for EnvStr {
1200    type Error = crate::types::bounded_string::BoundedStringError;
1201    fn try_from(value: String) -> Result<Self, Self::Error> {
1202        crate::types::bounded_string::BoundedString::new(value)
1203    }
1204}
1205impl ::serde::Serialize for EnvStr {
1206    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1207    where
1208        S: ::serde::Serializer,
1209    {
1210        crate::types::bounded_string::serialize_bounded_string(self, serializer)
1211    }
1212}
1213impl<'de> ::serde::Deserialize<'de> for EnvStr {
1214    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1215    where
1216        D: ::serde::Deserializer<'de>,
1217    {
1218        crate::types::bounded_string::deserialize_bounded_string(deserializer)
1219    }
1220}
1221#[derive(Debug, Clone, PartialEq, PartialOrd)]
1222pub struct HostnameStr {
1223    value: String,
1224}
1225impl crate::types::bounded_string::BoundedString for HostnameStr {
1226    const MIN_LENGTH: Option<usize> = None::<usize>;
1227    const MAX_LENGTH: Option<usize> = Some(255usize);
1228    const DEFAULT: Option<&'static str> = None::<&'static str>;
1229    const PATTERN: Option<&'static str> = None::<&'static str>;
1230    const TYPE_DESCRIPTION: &'static str = "a string with length at most 255";
1231    fn get_value(&self) -> &str {
1232        &self.value
1233    }
1234    fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
1235        Self::validate(&value)?;
1236        Ok(Self { value })
1237    }
1238}
1239impl std::convert::TryFrom<String> for HostnameStr {
1240    type Error = crate::types::bounded_string::BoundedStringError;
1241    fn try_from(value: String) -> Result<Self, Self::Error> {
1242        crate::types::bounded_string::BoundedString::new(value)
1243    }
1244}
1245impl ::serde::Serialize for HostnameStr {
1246    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1247    where
1248        S: ::serde::Serializer,
1249    {
1250        crate::types::bounded_string::serialize_bounded_string(self, serializer)
1251    }
1252}
1253impl<'de> ::serde::Deserialize<'de> for HostnameStr {
1254    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1255    where
1256        D: ::serde::Deserializer<'de>,
1257    {
1258        crate::types::bounded_string::deserialize_bounded_string(deserializer)
1259    }
1260}
1261#[derive(Debug, Clone, PartialEq, PartialOrd)]
1262pub struct OstemplateStr {
1263    value: String,
1264}
1265impl crate::types::bounded_string::BoundedString for OstemplateStr {
1266    const MIN_LENGTH: Option<usize> = None::<usize>;
1267    const MAX_LENGTH: Option<usize> = Some(255usize);
1268    const DEFAULT: Option<&'static str> = None::<&'static str>;
1269    const PATTERN: Option<&'static str> = None::<&'static str>;
1270    const TYPE_DESCRIPTION: &'static str = "a string with length at most 255";
1271    fn get_value(&self) -> &str {
1272        &self.value
1273    }
1274    fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
1275        Self::validate(&value)?;
1276        Ok(Self { value })
1277    }
1278}
1279impl std::convert::TryFrom<String> for OstemplateStr {
1280    type Error = crate::types::bounded_string::BoundedStringError;
1281    fn try_from(value: String) -> Result<Self, Self::Error> {
1282        crate::types::bounded_string::BoundedString::new(value)
1283    }
1284}
1285impl ::serde::Serialize for OstemplateStr {
1286    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1287    where
1288        S: ::serde::Serializer,
1289    {
1290        crate::types::bounded_string::serialize_bounded_string(self, serializer)
1291    }
1292}
1293impl<'de> ::serde::Deserialize<'de> for OstemplateStr {
1294    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1295    where
1296        D: ::serde::Deserializer<'de>,
1297    {
1298        crate::types::bounded_string::deserialize_bounded_string(deserializer)
1299    }
1300}
1301#[derive(Debug, Clone, PartialEq, PartialOrd)]
1302pub struct PasswordStr {
1303    value: String,
1304}
1305impl crate::types::bounded_string::BoundedString for PasswordStr {
1306    const MIN_LENGTH: Option<usize> = Some(5usize);
1307    const MAX_LENGTH: Option<usize> = None::<usize>;
1308    const DEFAULT: Option<&'static str> = None::<&'static str>;
1309    const PATTERN: Option<&'static str> = None::<&'static str>;
1310    const TYPE_DESCRIPTION: &'static str = "a string with length at least 5";
1311    fn get_value(&self) -> &str {
1312        &self.value
1313    }
1314    fn new(value: String) -> Result<Self, crate::types::bounded_string::BoundedStringError> {
1315        Self::validate(&value)?;
1316        Ok(Self { value })
1317    }
1318}
1319impl std::convert::TryFrom<String> for PasswordStr {
1320    type Error = crate::types::bounded_string::BoundedStringError;
1321    fn try_from(value: String) -> Result<Self, Self::Error> {
1322        crate::types::bounded_string::BoundedString::new(value)
1323    }
1324}
1325impl ::serde::Serialize for PasswordStr {
1326    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1327    where
1328        S: ::serde::Serializer,
1329    {
1330        crate::types::bounded_string::serialize_bounded_string(self, serializer)
1331    }
1332}
1333impl<'de> ::serde::Deserialize<'de> for PasswordStr {
1334    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1335    where
1336        D: ::serde::Deserializer<'de>,
1337    {
1338        crate::types::bounded_string::deserialize_bounded_string(deserializer)
1339    }
1340}
1341impl<T> LxcClient<T>
1342where
1343    T: crate::client::Client,
1344{
1345    pub fn vmid(&self, vmid: crate::types::VmId) -> vmid::VmidClient<T> {
1346        vmid::VmidClient::<T>::new(self.client.clone(), &self.path, vmid)
1347    }
1348}
proxmox_api/generated/nodes/node/lxc.rs

proxmox_api/generated/nodes/node/
lxc.rs
