azure_lite_rs/types/
compute.rs

1//! Types for the Azure Compute API (v1).
2//!
3//! Auto-generated from the Azure ARM REST Specification.
4//! **Do not edit manually** — modify the manifest and re-run codegen.
5
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8
9/// An Azure virtual machine resource.
10///
11/// **Azure API**: `compute.v1.VirtualMachine`
12/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachine>
13#[derive(Debug, Clone, Default, Serialize, Deserialize)]
14#[serde(rename_all = "camelCase")]
15pub struct VirtualMachine {
16    /// Resource ID
17    #[serde(skip_serializing_if = "Option::is_none")]
18    pub id: Option<String>,
19
20    /// Resource name
21    #[serde(skip_serializing_if = "Option::is_none")]
22    pub name: Option<String>,
23
24    /// Resource type
25    #[serde(rename = "type")]
26    #[serde(skip_serializing_if = "Option::is_none")]
27    pub r#type: Option<String>,
28
29    /// Resource location
30    #[serde(skip_serializing_if = "Option::is_none")]
31    pub location: Option<String>,
32
33    /// Resource tags
34    #[serde(default)]
35    #[serde(skip_serializing_if = "HashMap::is_empty")]
36    pub tags: HashMap<String, String>,
37
38    /// Availability zones
39    #[serde(default)]
40    #[serde(skip_serializing_if = "Vec::is_empty")]
41    pub zones: Vec<String>,
42
43    /// VM properties
44    #[serde(skip_serializing_if = "Option::is_none")]
45    pub properties: Option<VirtualMachineProperties>,
46}
47
48impl VirtualMachine {
49    #[cfg(any(test, feature = "test-support"))]
50    /// Create a fixture instance for testing.
51    pub fn fixture() -> Self {
52        Self {
53            id: Some("test-id".into()),
54            name: Some("test-virtual_machine".into()),
55            r#type: Some("test-type".into()),
56            location: Some("test-location".into()),
57            tags: Default::default(),
58            zones: vec![],
59            properties: Some(VirtualMachineProperties::fixture()),
60        }
61    }
62}
63
64/// Properties of a virtual machine.
65///
66/// **Azure API**: `compute.v1.VirtualMachineProperties`
67/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineProperties>
68#[derive(Debug, Clone, Default, Serialize, Deserialize)]
69#[serde(rename_all = "camelCase")]
70pub struct VirtualMachineProperties {
71    /// Unique VM identifier
72    #[serde(skip_serializing_if = "Option::is_none")]
73    pub vm_id: Option<String>,
74
75    /// Provisioning state (Succeeded, Failed, etc.)
76    #[serde(skip_serializing_if = "Option::is_none")]
77    pub provisioning_state: Option<String>,
78
79    /// Hardware profile (VM size)
80    #[serde(skip_serializing_if = "Option::is_none")]
81    pub hardware_profile: Option<HardwareProfile>,
82
83    /// Storage profile (disks, image)
84    #[serde(skip_serializing_if = "Option::is_none")]
85    pub storage_profile: Option<StorageProfile>,
86
87    /// OS profile (admin user, computer name)
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub os_profile: Option<OsProfile>,
90
91    /// Network profile (NICs)
92    #[serde(skip_serializing_if = "Option::is_none")]
93    pub network_profile: Option<NetworkProfile>,
94
95    /// Diagnostics profile (boot diagnostics)
96    #[serde(skip_serializing_if = "Option::is_none")]
97    pub diagnostics_profile: Option<DiagnosticsProfile>,
98
99    /// License type for hybrid benefit
100    #[serde(skip_serializing_if = "Option::is_none")]
101    pub license_type: Option<String>,
102
103    /// VM priority (Regular, Low, Spot)
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub priority: Option<String>,
106
107    /// Eviction policy for Spot VMs
108    #[serde(skip_serializing_if = "Option::is_none")]
109    pub eviction_policy: Option<String>,
110
111    /// Time when the VM was created
112    #[serde(skip_serializing_if = "Option::is_none")]
113    pub time_created: Option<String>,
114
115    /// Instance view status (when $expand=instanceView)
116    #[serde(skip_serializing_if = "Option::is_none")]
117    pub instance_view: Option<VirtualMachineInstanceView>,
118}
119
120impl VirtualMachineProperties {
121    #[cfg(any(test, feature = "test-support"))]
122    /// Create a fixture instance for testing.
123    pub fn fixture() -> Self {
124        Self {
125            vm_id: Some("test-vm_id".into()),
126            provisioning_state: Some("test-provisioning_state".into()),
127            hardware_profile: Some(HardwareProfile::fixture()),
128            storage_profile: Some(StorageProfile::fixture()),
129            os_profile: Some(OsProfile::fixture()),
130            network_profile: Some(NetworkProfile::fixture()),
131            diagnostics_profile: Some(DiagnosticsProfile::fixture()),
132            license_type: Some("test-license_type".into()),
133            priority: Some("test-priority".into()),
134            eviction_policy: Some("test-eviction_policy".into()),
135            time_created: Some("test-time_created".into()),
136            instance_view: Some(VirtualMachineInstanceView::fixture()),
137        }
138    }
139}
140
141/// Specifies the hardware settings for the virtual machine.
142///
143/// **Azure API**: `compute.v1.HardwareProfile`
144/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//HardwareProfile>
145#[derive(Debug, Clone, Default, Serialize, Deserialize)]
146#[serde(rename_all = "camelCase")]
147pub struct HardwareProfile {
148    /// VM size name (e.g. Standard_D2s_v3)
149    #[serde(skip_serializing_if = "Option::is_none")]
150    pub vm_size: Option<String>,
151}
152
153impl HardwareProfile {
154    #[cfg(any(test, feature = "test-support"))]
155    /// Create a fixture instance for testing.
156    pub fn fixture() -> Self {
157        Self {
158            vm_size: Some("test-vm_size".into()),
159        }
160    }
161}
162
163/// Storage profile for a VM.
164///
165/// **Azure API**: `compute.v1.StorageProfile`
166/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//StorageProfile>
167#[derive(Debug, Clone, Default, Serialize, Deserialize)]
168#[serde(rename_all = "camelCase")]
169pub struct StorageProfile {
170    /// Image reference for the OS disk
171    #[serde(skip_serializing_if = "Option::is_none")]
172    pub image_reference: Option<ImageReference>,
173
174    /// OS disk settings
175    #[serde(skip_serializing_if = "Option::is_none")]
176    pub os_disk: Option<OsDisk>,
177
178    /// Data disks attached to the VM
179    #[serde(default)]
180    #[serde(skip_serializing_if = "Vec::is_empty")]
181    pub data_disks: Vec<DataDisk>,
182}
183
184impl StorageProfile {
185    #[cfg(any(test, feature = "test-support"))]
186    /// Create a fixture instance for testing.
187    pub fn fixture() -> Self {
188        Self {
189            image_reference: Some(ImageReference::fixture()),
190            os_disk: Some(OsDisk::fixture()),
191            data_disks: vec![],
192        }
193    }
194}
195
196/// Reference to a platform or marketplace image.
197///
198/// **Azure API**: `compute.v1.ImageReference`
199/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//ImageReference>
200#[derive(Debug, Clone, Default, Serialize, Deserialize)]
201#[serde(rename_all = "camelCase")]
202pub struct ImageReference {
203    /// Resource ID of a shared gallery image
204    #[serde(skip_serializing_if = "Option::is_none")]
205    pub id: Option<String>,
206
207    /// Image publisher
208    #[serde(skip_serializing_if = "Option::is_none")]
209    pub publisher: Option<String>,
210
211    /// Image offer
212    #[serde(skip_serializing_if = "Option::is_none")]
213    pub offer: Option<String>,
214
215    /// Image SKU
216    #[serde(skip_serializing_if = "Option::is_none")]
217    pub sku: Option<String>,
218
219    /// Image version
220    #[serde(skip_serializing_if = "Option::is_none")]
221    pub version: Option<String>,
222
223    /// Exact image version in use
224    #[serde(skip_serializing_if = "Option::is_none")]
225    pub exact_version: Option<String>,
226}
227
228impl ImageReference {
229    #[cfg(any(test, feature = "test-support"))]
230    /// Create a fixture instance for testing.
231    pub fn fixture() -> Self {
232        Self {
233            id: Some("test-id".into()),
234            publisher: Some("test-publisher".into()),
235            offer: Some("test-offer".into()),
236            sku: Some("test-sku".into()),
237            version: Some("test-version".into()),
238            exact_version: Some("test-exact_version".into()),
239        }
240    }
241}
242
243/// OS disk settings.
244///
245/// **Azure API**: `compute.v1.OsDisk`
246/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//OsDisk>
247#[derive(Debug, Clone, Default, Serialize, Deserialize)]
248#[serde(rename_all = "camelCase")]
249pub struct OsDisk {
250    /// Operating system type (Windows or Linux)
251    #[serde(skip_serializing_if = "Option::is_none")]
252    pub os_type: Option<String>,
253
254    /// Disk name
255    #[serde(skip_serializing_if = "Option::is_none")]
256    pub name: Option<String>,
257
258    /// How the disk was created (FromImage, Attach, Empty)
259    pub create_option: String,
260
261    /// Host caching mode (None, ReadOnly, ReadWrite)
262    #[serde(skip_serializing_if = "Option::is_none")]
263    pub caching: Option<String>,
264
265    /// Disk size in GB
266    #[serde(rename = "diskSizeGB")]
267    #[serde(skip_serializing_if = "Option::is_none")]
268    pub disk_size_gb: Option<i32>,
269
270    /// Managed disk parameters
271    #[serde(skip_serializing_if = "Option::is_none")]
272    pub managed_disk: Option<ManagedDiskParameters>,
273
274    /// Delete option on VM delete (Delete, Detach)
275    #[serde(skip_serializing_if = "Option::is_none")]
276    pub delete_option: Option<String>,
277}
278
279impl OsDisk {
280    #[cfg(any(test, feature = "test-support"))]
281    /// Create a fixture instance for testing.
282    pub fn fixture() -> Self {
283        Self {
284            os_type: Some("test-os_type".into()),
285            name: Some("test-os_disk".into()),
286            create_option: "test-create_option".into(),
287            caching: Some("test-caching".into()),
288            disk_size_gb: Some(100),
289            managed_disk: Some(ManagedDiskParameters::fixture()),
290            delete_option: Some("test-delete_option".into()),
291        }
292    }
293}
294
295/// A data disk attached to a VM.
296///
297/// **Azure API**: `compute.v1.DataDisk`
298/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//DataDisk>
299#[derive(Debug, Clone, Default, Serialize, Deserialize)]
300#[serde(rename_all = "camelCase")]
301pub struct DataDisk {
302    /// Logical unit number
303    pub lun: i32,
304
305    /// Disk name
306    #[serde(skip_serializing_if = "Option::is_none")]
307    pub name: Option<String>,
308
309    /// How the disk was created
310    pub create_option: String,
311
312    /// Host caching mode
313    #[serde(skip_serializing_if = "Option::is_none")]
314    pub caching: Option<String>,
315
316    /// Disk size in GB
317    #[serde(rename = "diskSizeGB")]
318    #[serde(skip_serializing_if = "Option::is_none")]
319    pub disk_size_gb: Option<i32>,
320
321    /// Managed disk parameters
322    #[serde(skip_serializing_if = "Option::is_none")]
323    pub managed_disk: Option<ManagedDiskParameters>,
324
325    /// Delete option on VM delete
326    #[serde(skip_serializing_if = "Option::is_none")]
327    pub delete_option: Option<String>,
328}
329
330impl DataDisk {
331    #[cfg(any(test, feature = "test-support"))]
332    /// Create a fixture instance for testing.
333    pub fn fixture() -> Self {
334        Self {
335            lun: 100,
336            name: Some("test-data_disk".into()),
337            create_option: "test-create_option".into(),
338            caching: Some("test-caching".into()),
339            disk_size_gb: Some(100),
340            managed_disk: Some(ManagedDiskParameters::fixture()),
341            delete_option: Some("test-delete_option".into()),
342        }
343    }
344}
345
346/// Managed disk parameters.
347///
348/// **Azure API**: `compute.v1.ManagedDiskParameters`
349/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//ManagedDiskParameters>
350#[derive(Debug, Clone, Default, Serialize, Deserialize)]
351#[serde(rename_all = "camelCase")]
352pub struct ManagedDiskParameters {
353    /// Resource ID of the managed disk
354    #[serde(skip_serializing_if = "Option::is_none")]
355    pub id: Option<String>,
356
357    /// Storage account type (Standard_LRS, Premium_LRS, etc.)
358    #[serde(skip_serializing_if = "Option::is_none")]
359    pub storage_account_type: Option<String>,
360}
361
362impl ManagedDiskParameters {
363    #[cfg(any(test, feature = "test-support"))]
364    /// Create a fixture instance for testing.
365    pub fn fixture() -> Self {
366        Self {
367            id: Some("test-id".into()),
368            storage_account_type: Some("test-storage_account_type".into()),
369        }
370    }
371}
372
373/// OS profile for a VM.
374///
375/// **Azure API**: `compute.v1.OsProfile`
376/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//OsProfile>
377#[derive(Debug, Clone, Default, Serialize, Deserialize)]
378#[serde(rename_all = "camelCase")]
379pub struct OsProfile {
380    /// Computer host name
381    #[serde(skip_serializing_if = "Option::is_none")]
382    pub computer_name: Option<String>,
383
384    /// Admin username
385    #[serde(skip_serializing_if = "Option::is_none")]
386    pub admin_username: Option<String>,
387
388    /// Admin password (write-only)
389    #[serde(skip_serializing_if = "Option::is_none")]
390    pub admin_password: Option<String>,
391
392    /// Linux-specific configuration
393    #[serde(skip_serializing_if = "Option::is_none")]
394    pub linux_configuration: Option<LinuxConfiguration>,
395
396    /// Windows-specific configuration
397    #[serde(skip_serializing_if = "Option::is_none")]
398    pub windows_configuration: Option<WindowsConfiguration>,
399}
400
401impl OsProfile {
402    #[cfg(any(test, feature = "test-support"))]
403    /// Create a fixture instance for testing.
404    pub fn fixture() -> Self {
405        Self {
406            computer_name: Some("test-computer_name".into()),
407            admin_username: Some("test-admin_username".into()),
408            admin_password: Some("test-admin_password".into()),
409            linux_configuration: Some(LinuxConfiguration::fixture()),
410            windows_configuration: Some(WindowsConfiguration::fixture()),
411        }
412    }
413}
414
415/// Linux-specific OS configuration.
416///
417/// **Azure API**: `compute.v1.LinuxConfiguration`
418/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//LinuxConfiguration>
419#[derive(Debug, Clone, Default, Serialize, Deserialize)]
420#[serde(rename_all = "camelCase")]
421pub struct LinuxConfiguration {
422    /// Disable password auth (use SSH keys)
423    #[serde(skip_serializing_if = "Option::is_none")]
424    pub disable_password_authentication: Option<bool>,
425
426    /// Whether to provision the VM agent
427    #[serde(rename = "provisionVMAgent")]
428    #[serde(skip_serializing_if = "Option::is_none")]
429    pub provision_vm_agent: Option<bool>,
430
431    /// SSH configuration
432    #[serde(skip_serializing_if = "Option::is_none")]
433    pub ssh: Option<SshConfiguration>,
434}
435
436impl LinuxConfiguration {
437    #[cfg(any(test, feature = "test-support"))]
438    /// Create a fixture instance for testing.
439    pub fn fixture() -> Self {
440        Self {
441            disable_password_authentication: Some(false),
442            provision_vm_agent: Some(false),
443            ssh: Some(SshConfiguration::fixture()),
444        }
445    }
446}
447
448/// Windows-specific OS configuration.
449///
450/// **Azure API**: `compute.v1.WindowsConfiguration`
451/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//WindowsConfiguration>
452#[derive(Debug, Clone, Default, Serialize, Deserialize)]
453#[serde(rename_all = "camelCase")]
454pub struct WindowsConfiguration {
455    /// Whether to provision the VM agent
456    #[serde(rename = "provisionVMAgent")]
457    #[serde(skip_serializing_if = "Option::is_none")]
458    pub provision_vm_agent: Option<bool>,
459
460    /// Enable automatic Windows updates
461    #[serde(skip_serializing_if = "Option::is_none")]
462    pub enable_automatic_updates: Option<bool>,
463}
464
465impl WindowsConfiguration {
466    #[cfg(any(test, feature = "test-support"))]
467    /// Create a fixture instance for testing.
468    pub fn fixture() -> Self {
469        Self {
470            provision_vm_agent: Some(false),
471            enable_automatic_updates: Some(false),
472        }
473    }
474}
475
476/// SSH configuration.
477///
478/// **Azure API**: `compute.v1.SshConfiguration`
479/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//SshConfiguration>
480#[derive(Debug, Clone, Default, Serialize, Deserialize)]
481#[serde(rename_all = "camelCase")]
482pub struct SshConfiguration {
483    /// SSH public keys
484    #[serde(default)]
485    #[serde(skip_serializing_if = "Vec::is_empty")]
486    pub public_keys: Vec<SshPublicKey>,
487}
488
489impl SshConfiguration {
490    #[cfg(any(test, feature = "test-support"))]
491    /// Create a fixture instance for testing.
492    pub fn fixture() -> Self {
493        Self {
494            public_keys: vec![],
495        }
496    }
497}
498
499/// SSH public key for Linux VMs.
500///
501/// **Azure API**: `compute.v1.SshPublicKey`
502/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//SshPublicKey>
503#[derive(Debug, Clone, Default, Serialize, Deserialize)]
504#[serde(rename_all = "camelCase")]
505pub struct SshPublicKey {
506    /// Path where the key is placed (e.g. /home/user/.ssh/authorized_keys)
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub path: Option<String>,
509
510    /// SSH public key data
511    #[serde(skip_serializing_if = "Option::is_none")]
512    pub key_data: Option<String>,
513}
514
515impl SshPublicKey {
516    #[cfg(any(test, feature = "test-support"))]
517    /// Create a fixture instance for testing.
518    pub fn fixture() -> Self {
519        Self {
520            path: Some("test-path".into()),
521            key_data: Some("test-key_data".into()),
522        }
523    }
524}
525
526/// Network profile for a VM.
527///
528/// **Azure API**: `compute.v1.NetworkProfile`
529/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//NetworkProfile>
530#[derive(Debug, Clone, Default, Serialize, Deserialize)]
531#[serde(rename_all = "camelCase")]
532pub struct NetworkProfile {
533    /// Network interfaces attached to the VM
534    #[serde(default)]
535    #[serde(skip_serializing_if = "Vec::is_empty")]
536    pub network_interfaces: Vec<NetworkInterfaceReference>,
537}
538
539impl NetworkProfile {
540    #[cfg(any(test, feature = "test-support"))]
541    /// Create a fixture instance for testing.
542    pub fn fixture() -> Self {
543        Self {
544            network_interfaces: vec![],
545        }
546    }
547}
548
549/// Reference to a network interface.
550///
551/// **Azure API**: `compute.v1.NetworkInterfaceReference`
552/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//NetworkInterfaceReference>
553#[derive(Debug, Clone, Default, Serialize, Deserialize)]
554#[serde(rename_all = "camelCase")]
555pub struct NetworkInterfaceReference {
556    /// Resource ID of the NIC
557    #[serde(skip_serializing_if = "Option::is_none")]
558    pub id: Option<String>,
559
560    /// NIC reference properties
561    #[serde(skip_serializing_if = "Option::is_none")]
562    pub properties: Option<NetworkInterfaceReferenceProperties>,
563}
564
565impl NetworkInterfaceReference {
566    #[cfg(any(test, feature = "test-support"))]
567    /// Create a fixture instance for testing.
568    pub fn fixture() -> Self {
569        Self {
570            id: Some("test-id".into()),
571            properties: Some(NetworkInterfaceReferenceProperties::fixture()),
572        }
573    }
574}
575
576/// Properties of a NIC reference.
577///
578/// **Azure API**: `compute.v1.NetworkInterfaceReferenceProperties`
579/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//NetworkInterfaceReferenceProperties>
580#[derive(Debug, Clone, Default, Serialize, Deserialize)]
581#[serde(rename_all = "camelCase")]
582pub struct NetworkInterfaceReferenceProperties {
583    /// Whether this is the primary NIC
584    #[serde(skip_serializing_if = "Option::is_none")]
585    pub primary: Option<bool>,
586
587    /// Delete option on VM delete
588    #[serde(skip_serializing_if = "Option::is_none")]
589    pub delete_option: Option<String>,
590}
591
592impl NetworkInterfaceReferenceProperties {
593    #[cfg(any(test, feature = "test-support"))]
594    /// Create a fixture instance for testing.
595    pub fn fixture() -> Self {
596        Self {
597            primary: Some(false),
598            delete_option: Some("test-delete_option".into()),
599        }
600    }
601}
602
603/// Diagnostics profile.
604///
605/// **Azure API**: `compute.v1.DiagnosticsProfile`
606/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//DiagnosticsProfile>
607#[derive(Debug, Clone, Default, Serialize, Deserialize)]
608#[serde(rename_all = "camelCase")]
609pub struct DiagnosticsProfile {
610    /// Boot diagnostics settings
611    #[serde(skip_serializing_if = "Option::is_none")]
612    pub boot_diagnostics: Option<BootDiagnostics>,
613}
614
615impl DiagnosticsProfile {
616    #[cfg(any(test, feature = "test-support"))]
617    /// Create a fixture instance for testing.
618    pub fn fixture() -> Self {
619        Self {
620            boot_diagnostics: Some(BootDiagnostics::fixture()),
621        }
622    }
623}
624
625/// Boot diagnostics configuration.
626///
627/// **Azure API**: `compute.v1.BootDiagnostics`
628/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//BootDiagnostics>
629#[derive(Debug, Clone, Default, Serialize, Deserialize)]
630#[serde(rename_all = "camelCase")]
631pub struct BootDiagnostics {
632    /// Whether boot diagnostics is enabled
633    #[serde(skip_serializing_if = "Option::is_none")]
634    pub enabled: Option<bool>,
635
636    /// Storage account URI for boot diagnostics
637    #[serde(skip_serializing_if = "Option::is_none")]
638    pub storage_uri: Option<String>,
639}
640
641impl BootDiagnostics {
642    #[cfg(any(test, feature = "test-support"))]
643    /// Create a fixture instance for testing.
644    pub fn fixture() -> Self {
645        Self {
646            enabled: Some(false),
647            storage_uri: Some("test-storage_uri".into()),
648        }
649    }
650}
651
652/// Instance view of a virtual machine.
653///
654/// **Azure API**: `compute.v1.VirtualMachineInstanceView`
655/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineInstanceView>
656#[derive(Debug, Clone, Default, Serialize, Deserialize)]
657#[serde(rename_all = "camelCase")]
658pub struct VirtualMachineInstanceView {
659    /// Update domain
660    #[serde(skip_serializing_if = "Option::is_none")]
661    pub platform_update_domain: Option<i32>,
662
663    /// Fault domain
664    #[serde(skip_serializing_if = "Option::is_none")]
665    pub platform_fault_domain: Option<i32>,
666
667    /// Computer name
668    #[serde(skip_serializing_if = "Option::is_none")]
669    pub computer_name: Option<String>,
670
671    /// Operating system name
672    #[serde(skip_serializing_if = "Option::is_none")]
673    pub os_name: Option<String>,
674
675    /// Operating system version
676    #[serde(skip_serializing_if = "Option::is_none")]
677    pub os_version: Option<String>,
678
679    /// VM agent instance view
680    #[serde(skip_serializing_if = "Option::is_none")]
681    pub vm_agent: Option<VirtualMachineAgentInstanceView>,
682
683    /// Resource status information
684    #[serde(default)]
685    #[serde(skip_serializing_if = "Vec::is_empty")]
686    pub statuses: Vec<InstanceViewStatus>,
687}
688
689impl VirtualMachineInstanceView {
690    #[cfg(any(test, feature = "test-support"))]
691    /// Create a fixture instance for testing.
692    pub fn fixture() -> Self {
693        Self {
694            platform_update_domain: Some(100),
695            platform_fault_domain: Some(100),
696            computer_name: Some("test-computer_name".into()),
697            os_name: Some("test-os_name".into()),
698            os_version: Some("test-os_version".into()),
699            vm_agent: Some(VirtualMachineAgentInstanceView::fixture()),
700            statuses: vec![],
701        }
702    }
703}
704
705/// Instance view of the VM agent.
706///
707/// **Azure API**: `compute.v1.VirtualMachineAgentInstanceView`
708/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineAgentInstanceView>
709#[derive(Debug, Clone, Default, Serialize, Deserialize)]
710#[serde(rename_all = "camelCase")]
711pub struct VirtualMachineAgentInstanceView {
712    /// VM agent version
713    #[serde(skip_serializing_if = "Option::is_none")]
714    pub vm_agent_version: Option<String>,
715
716    /// Agent status information
717    #[serde(default)]
718    #[serde(skip_serializing_if = "Vec::is_empty")]
719    pub statuses: Vec<InstanceViewStatus>,
720}
721
722impl VirtualMachineAgentInstanceView {
723    #[cfg(any(test, feature = "test-support"))]
724    /// Create a fixture instance for testing.
725    pub fn fixture() -> Self {
726        Self {
727            vm_agent_version: Some("test-vm_agent_version".into()),
728            statuses: vec![],
729        }
730    }
731}
732
733/// Instance view status.
734///
735/// **Azure API**: `compute.v1.InstanceViewStatus`
736/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//InstanceViewStatus>
737#[derive(Debug, Clone, Default, Serialize, Deserialize)]
738#[serde(rename_all = "camelCase")]
739pub struct InstanceViewStatus {
740    /// Status code
741    #[serde(skip_serializing_if = "Option::is_none")]
742    pub code: Option<String>,
743
744    /// Level (Info, Warning, Error)
745    #[serde(skip_serializing_if = "Option::is_none")]
746    pub level: Option<String>,
747
748    /// Display status text
749    #[serde(skip_serializing_if = "Option::is_none")]
750    pub display_status: Option<String>,
751
752    /// Detailed status message
753    #[serde(skip_serializing_if = "Option::is_none")]
754    pub message: Option<String>,
755
756    /// Status time
757    #[serde(skip_serializing_if = "Option::is_none")]
758    pub time: Option<String>,
759}
760
761impl InstanceViewStatus {
762    #[cfg(any(test, feature = "test-support"))]
763    /// Create a fixture instance for testing.
764    pub fn fixture() -> Self {
765        Self {
766            code: Some("test-code".into()),
767            level: Some("test-level".into()),
768            display_status: Some("test-display_status".into()),
769            message: Some("test-message".into()),
770            time: Some("test-time".into()),
771        }
772    }
773}
774
775/// Response for listing virtual machines.
776///
777/// **Azure API**: `compute.v1.VirtualMachineListResult`
778/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineListResult>
779#[derive(Debug, Clone, Default, Serialize, Deserialize)]
780#[serde(rename_all = "camelCase")]
781pub struct VirtualMachineListResult {
782    /// List of virtual machines
783    #[serde(default)]
784    pub value: Vec<VirtualMachine>,
785
786    /// URL to get the next page of results
787    #[serde(skip_serializing_if = "Option::is_none")]
788    pub next_link: Option<String>,
789}
790
791impl VirtualMachineListResult {
792    #[cfg(any(test, feature = "test-support"))]
793    /// Create a fixture instance for testing.
794    pub fn fixture() -> Self {
795        Self {
796            value: vec![],
797            next_link: Some("test-next_link".into()),
798        }
799    }
800}
801
802/// Request body for creating or updating a virtual machine.
803///
804/// **Azure API**: `compute.v1.VirtualMachineCreateRequest`
805/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineCreateRequest>
806#[derive(Debug, Clone, Default, Serialize, Deserialize)]
807#[serde(rename_all = "camelCase")]
808pub struct VirtualMachineCreateRequest {
809    /// Resource location
810    pub location: String,
811
812    /// Resource tags
813    #[serde(default)]
814    #[serde(skip_serializing_if = "HashMap::is_empty")]
815    pub tags: HashMap<String, String>,
816
817    /// Availability zones
818    #[serde(default)]
819    #[serde(skip_serializing_if = "Vec::is_empty")]
820    pub zones: Vec<String>,
821
822    /// VM properties
823    #[serde(skip_serializing_if = "Option::is_none")]
824    pub properties: Option<VirtualMachineProperties>,
825}
826
827impl VirtualMachineCreateRequest {
828    #[cfg(any(test, feature = "test-support"))]
829    /// Create a fixture instance for testing.
830    pub fn fixture() -> Self {
831        Self {
832            location: "test-location".into(),
833            tags: Default::default(),
834            zones: vec![],
835            properties: Some(VirtualMachineProperties::fixture()),
836        }
837    }
838}
839
840/// Response for getting a VM instance view.
841///
842/// **Azure API**: `compute.v1.VirtualMachineInstanceViewResult`
843/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineInstanceViewResult>
844#[derive(Debug, Clone, Default, Serialize, Deserialize)]
845#[serde(rename_all = "camelCase")]
846pub struct VirtualMachineInstanceViewResult {
847    /// Update domain
848    #[serde(skip_serializing_if = "Option::is_none")]
849    pub platform_update_domain: Option<i32>,
850
851    /// Fault domain
852    #[serde(skip_serializing_if = "Option::is_none")]
853    pub platform_fault_domain: Option<i32>,
854
855    /// Computer name
856    #[serde(skip_serializing_if = "Option::is_none")]
857    pub computer_name: Option<String>,
858
859    /// Operating system name
860    #[serde(skip_serializing_if = "Option::is_none")]
861    pub os_name: Option<String>,
862
863    /// Operating system version
864    #[serde(skip_serializing_if = "Option::is_none")]
865    pub os_version: Option<String>,
866
867    /// VM agent instance view
868    #[serde(skip_serializing_if = "Option::is_none")]
869    pub vm_agent: Option<VirtualMachineAgentInstanceView>,
870
871    /// Resource status information
872    #[serde(default)]
873    #[serde(skip_serializing_if = "Vec::is_empty")]
874    pub statuses: Vec<InstanceViewStatus>,
875}
876
877impl VirtualMachineInstanceViewResult {
878    #[cfg(any(test, feature = "test-support"))]
879    /// Create a fixture instance for testing.
880    pub fn fixture() -> Self {
881        Self {
882            platform_update_domain: Some(100),
883            platform_fault_domain: Some(100),
884            computer_name: Some("test-computer_name".into()),
885            os_name: Some("test-os_name".into()),
886            os_version: Some("test-os_version".into()),
887            vm_agent: Some(VirtualMachineAgentInstanceView::fixture()),
888            statuses: vec![],
889        }
890    }
891}
892
893/// Describes a virtual machine scale set sku.
894///
895/// **Azure API**: `compute.v1.Sku`
896/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//Sku>
897#[derive(Debug, Clone, Default, Serialize, Deserialize)]
898#[serde(rename_all = "camelCase")]
899pub struct Sku {
900    /// The sku name (e.g. Standard_D2s_v3)
901    #[serde(skip_serializing_if = "Option::is_none")]
902    pub name: Option<String>,
903
904    /// The sku tier (Standard, Basic)
905    #[serde(skip_serializing_if = "Option::is_none")]
906    pub tier: Option<String>,
907
908    /// Number of instances in the scale set
909    #[serde(skip_serializing_if = "Option::is_none")]
910    pub capacity: Option<i64>,
911}
912
913impl Sku {
914    #[cfg(any(test, feature = "test-support"))]
915    /// Create a fixture instance for testing.
916    pub fn fixture() -> Self {
917        Self {
918            name: Some("test-sku".into()),
919            tier: Some("test-tier".into()),
920            capacity: Some(100),
921        }
922    }
923}
924
925/// Describes an upgrade policy.
926///
927/// **Azure API**: `compute.v1.UpgradePolicy`
928/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//UpgradePolicy>
929#[derive(Debug, Clone, Default, Serialize, Deserialize)]
930#[serde(rename_all = "camelCase")]
931pub struct UpgradePolicy {
932    /// Upgrade mode: Manual, Rolling, or Automatic
933    #[serde(skip_serializing_if = "Option::is_none")]
934    pub mode: Option<String>,
935}
936
937impl UpgradePolicy {
938    #[cfg(any(test, feature = "test-support"))]
939    /// Create a fixture instance for testing.
940    pub fn fixture() -> Self {
941        Self {
942            mode: Some("test-mode".into()),
943        }
944    }
945}
946
947/// Describes a virtual machine scale set VM profile.
948///
949/// **Azure API**: `compute.v1.VirtualMachineScaleSetVMProfile`
950/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetVMProfile>
951#[derive(Debug, Clone, Default, Serialize, Deserialize)]
952#[serde(rename_all = "camelCase")]
953pub struct VirtualMachineScaleSetVMProfile {
954    /// OS profile for VMSS VMs
955    #[serde(skip_serializing_if = "Option::is_none")]
956    pub os_profile: Option<VirtualMachineScaleSetOsProfile>,
957
958    /// Storage profile (reuses VM StorageProfile)
959    #[serde(skip_serializing_if = "Option::is_none")]
960    pub storage_profile: Option<StorageProfile>,
961
962    /// Network profile for VMSS VMs
963    #[serde(skip_serializing_if = "Option::is_none")]
964    pub network_profile: Option<VirtualMachineScaleSetNetworkProfile>,
965}
966
967impl VirtualMachineScaleSetVMProfile {
968    #[cfg(any(test, feature = "test-support"))]
969    /// Create a fixture instance for testing.
970    pub fn fixture() -> Self {
971        Self {
972            os_profile: Some(VirtualMachineScaleSetOsProfile::fixture()),
973            storage_profile: Some(StorageProfile::fixture()),
974            network_profile: Some(VirtualMachineScaleSetNetworkProfile::fixture()),
975        }
976    }
977}
978
979/// OS profile for VMSS VMs.
980///
981/// **Azure API**: `compute.v1.VirtualMachineScaleSetOsProfile`
982/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetOsProfile>
983#[derive(Debug, Clone, Default, Serialize, Deserialize)]
984#[serde(rename_all = "camelCase")]
985pub struct VirtualMachineScaleSetOsProfile {
986    /// Computer name prefix for VM instances
987    #[serde(skip_serializing_if = "Option::is_none")]
988    pub computer_name_prefix: Option<String>,
989
990    /// Admin username
991    #[serde(skip_serializing_if = "Option::is_none")]
992    pub admin_username: Option<String>,
993
994    /// Admin password (write-only)
995    #[serde(skip_serializing_if = "Option::is_none")]
996    pub admin_password: Option<String>,
997
998    /// Linux-specific configuration
999    #[serde(skip_serializing_if = "Option::is_none")]
1000    pub linux_configuration: Option<LinuxConfiguration>,
1001
1002    /// Windows-specific configuration
1003    #[serde(skip_serializing_if = "Option::is_none")]
1004    pub windows_configuration: Option<WindowsConfiguration>,
1005}
1006
1007impl VirtualMachineScaleSetOsProfile {
1008    #[cfg(any(test, feature = "test-support"))]
1009    /// Create a fixture instance for testing.
1010    pub fn fixture() -> Self {
1011        Self {
1012            computer_name_prefix: Some("test-computer_name_prefix".into()),
1013            admin_username: Some("test-admin_username".into()),
1014            admin_password: Some("test-admin_password".into()),
1015            linux_configuration: Some(LinuxConfiguration::fixture()),
1016            windows_configuration: Some(WindowsConfiguration::fixture()),
1017        }
1018    }
1019}
1020
1021/// Network profile for a VMSS.
1022///
1023/// **Azure API**: `compute.v1.VirtualMachineScaleSetNetworkProfile`
1024/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetNetworkProfile>
1025#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1026#[serde(rename_all = "camelCase")]
1027pub struct VirtualMachineScaleSetNetworkProfile {
1028    /// Network interface configurations
1029    #[serde(default)]
1030    #[serde(skip_serializing_if = "Vec::is_empty")]
1031    pub network_interface_configurations: Vec<VirtualMachineScaleSetNetworkConfiguration>,
1032}
1033
1034impl VirtualMachineScaleSetNetworkProfile {
1035    #[cfg(any(test, feature = "test-support"))]
1036    /// Create a fixture instance for testing.
1037    pub fn fixture() -> Self {
1038        Self {
1039            network_interface_configurations: vec![],
1040        }
1041    }
1042}
1043
1044/// Network configuration for VMSS instances.
1045///
1046/// **Azure API**: `compute.v1.VirtualMachineScaleSetNetworkConfiguration`
1047/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetNetworkConfiguration>
1048#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1049#[serde(rename_all = "camelCase")]
1050pub struct VirtualMachineScaleSetNetworkConfiguration {
1051    /// Network configuration name
1052    pub name: String,
1053
1054    /// Network configuration properties
1055    #[serde(skip_serializing_if = "Option::is_none")]
1056    pub properties: Option<VirtualMachineScaleSetNetworkConfigurationProperties>,
1057}
1058
1059impl VirtualMachineScaleSetNetworkConfiguration {
1060    #[cfg(any(test, feature = "test-support"))]
1061    /// Create a fixture instance for testing.
1062    pub fn fixture() -> Self {
1063        Self {
1064            name: "test-virtual_machine_scale_set_network_configuration".into(),
1065            properties: Some(VirtualMachineScaleSetNetworkConfigurationProperties::fixture()),
1066        }
1067    }
1068}
1069
1070/// Properties of a VMSS network configuration.
1071///
1072/// **Azure API**: `compute.v1.VirtualMachineScaleSetNetworkConfigurationProperties`
1073/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetNetworkConfigurationProperties>
1074#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1075#[serde(rename_all = "camelCase")]
1076pub struct VirtualMachineScaleSetNetworkConfigurationProperties {
1077    /// Whether this is the primary NIC
1078    #[serde(skip_serializing_if = "Option::is_none")]
1079    pub primary: Option<bool>,
1080
1081    /// Whether IP forwarding is enabled
1082    #[serde(rename = "enableIPForwarding")]
1083    #[serde(skip_serializing_if = "Option::is_none")]
1084    pub enable_ip_forwarding: Option<bool>,
1085
1086    /// IP configurations
1087    #[serde(default)]
1088    #[serde(skip_serializing_if = "Vec::is_empty")]
1089    pub ip_configurations: Vec<VirtualMachineScaleSetIPConfiguration>,
1090}
1091
1092impl VirtualMachineScaleSetNetworkConfigurationProperties {
1093    #[cfg(any(test, feature = "test-support"))]
1094    /// Create a fixture instance for testing.
1095    pub fn fixture() -> Self {
1096        Self {
1097            primary: Some(false),
1098            enable_ip_forwarding: Some(false),
1099            ip_configurations: vec![],
1100        }
1101    }
1102}
1103
1104/// IP configuration for a VMSS NIC.
1105///
1106/// **Azure API**: `compute.v1.VirtualMachineScaleSetIPConfiguration`
1107/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetIPConfiguration>
1108#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1109#[serde(rename_all = "camelCase")]
1110pub struct VirtualMachineScaleSetIPConfiguration {
1111    /// IP configuration name
1112    pub name: String,
1113
1114    /// IP configuration properties
1115    #[serde(skip_serializing_if = "Option::is_none")]
1116    pub properties: Option<VirtualMachineScaleSetIPConfigurationProperties>,
1117}
1118
1119impl VirtualMachineScaleSetIPConfiguration {
1120    #[cfg(any(test, feature = "test-support"))]
1121    /// Create a fixture instance for testing.
1122    pub fn fixture() -> Self {
1123        Self {
1124            name: "test-virtual_machine_scale_set_ip_configuration".into(),
1125            properties: Some(VirtualMachineScaleSetIPConfigurationProperties::fixture()),
1126        }
1127    }
1128}
1129
1130/// Properties of a VMSS IP configuration.
1131///
1132/// **Azure API**: `compute.v1.VirtualMachineScaleSetIPConfigurationProperties`
1133/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetIPConfigurationProperties>
1134#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1135#[serde(rename_all = "camelCase")]
1136pub struct VirtualMachineScaleSetIPConfigurationProperties {
1137    /// Subnet reference
1138    #[serde(skip_serializing_if = "Option::is_none")]
1139    pub subnet: Option<SubResource>,
1140}
1141
1142impl VirtualMachineScaleSetIPConfigurationProperties {
1143    #[cfg(any(test, feature = "test-support"))]
1144    /// Create a fixture instance for testing.
1145    pub fn fixture() -> Self {
1146        Self {
1147            subnet: Some(SubResource::fixture()),
1148        }
1149    }
1150}
1151
1152/// Generic ARM sub-resource reference with ID.
1153///
1154/// **Azure API**: `compute.v1.SubResource`
1155/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//SubResource>
1156#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1157#[serde(rename_all = "camelCase")]
1158pub struct SubResource {
1159    /// Resource ID
1160    #[serde(skip_serializing_if = "Option::is_none")]
1161    pub id: Option<String>,
1162}
1163
1164impl SubResource {
1165    #[cfg(any(test, feature = "test-support"))]
1166    /// Create a fixture instance for testing.
1167    pub fn fixture() -> Self {
1168        Self {
1169            id: Some("test-id".into()),
1170        }
1171    }
1172}
1173
1174/// Properties of a virtual machine scale set.
1175///
1176/// **Azure API**: `compute.v1.VirtualMachineScaleSetProperties`
1177/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetProperties>
1178#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1179#[serde(rename_all = "camelCase")]
1180pub struct VirtualMachineScaleSetProperties {
1181    /// Provisioning state
1182    #[serde(skip_serializing_if = "Option::is_none")]
1183    pub provisioning_state: Option<String>,
1184
1185    /// Unique ID of the scale set
1186    #[serde(skip_serializing_if = "Option::is_none")]
1187    pub unique_id: Option<String>,
1188
1189    /// Whether to overprovision VMs during scaling
1190    #[serde(skip_serializing_if = "Option::is_none")]
1191    pub overprovision: Option<bool>,
1192
1193    /// Limits to single placement group (max 100 VMs)
1194    #[serde(skip_serializing_if = "Option::is_none")]
1195    pub single_placement_group: Option<bool>,
1196
1197    /// Fault domain count per placement group
1198    #[serde(skip_serializing_if = "Option::is_none")]
1199    pub platform_fault_domain_count: Option<i32>,
1200
1201    /// Upgrade policy configuration
1202    #[serde(skip_serializing_if = "Option::is_none")]
1203    pub upgrade_policy: Option<UpgradePolicy>,
1204
1205    /// VM profile template for instances
1206    #[serde(skip_serializing_if = "Option::is_none")]
1207    pub virtual_machine_profile: Option<VirtualMachineScaleSetVMProfile>,
1208}
1209
1210impl VirtualMachineScaleSetProperties {
1211    #[cfg(any(test, feature = "test-support"))]
1212    /// Create a fixture instance for testing.
1213    pub fn fixture() -> Self {
1214        Self {
1215            provisioning_state: Some("test-provisioning_state".into()),
1216            unique_id: Some("test-unique_id".into()),
1217            overprovision: Some(false),
1218            single_placement_group: Some(false),
1219            platform_fault_domain_count: Some(100),
1220            upgrade_policy: Some(UpgradePolicy::fixture()),
1221            virtual_machine_profile: Some(VirtualMachineScaleSetVMProfile::fixture()),
1222        }
1223    }
1224}
1225
1226/// An Azure virtual machine scale set resource.
1227///
1228/// **Azure API**: `compute.v1.VirtualMachineScaleSet`
1229/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSet>
1230#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1231#[serde(rename_all = "camelCase")]
1232pub struct VirtualMachineScaleSet {
1233    /// Resource ID
1234    #[serde(skip_serializing_if = "Option::is_none")]
1235    pub id: Option<String>,
1236
1237    /// Resource name
1238    #[serde(skip_serializing_if = "Option::is_none")]
1239    pub name: Option<String>,
1240
1241    /// Resource type
1242    #[serde(rename = "type")]
1243    #[serde(skip_serializing_if = "Option::is_none")]
1244    pub r#type: Option<String>,
1245
1246    /// Resource location
1247    #[serde(skip_serializing_if = "Option::is_none")]
1248    pub location: Option<String>,
1249
1250    /// Resource tags
1251    #[serde(default)]
1252    #[serde(skip_serializing_if = "HashMap::is_empty")]
1253    pub tags: HashMap<String, String>,
1254
1255    /// VMSS SKU (VM size + capacity)
1256    #[serde(skip_serializing_if = "Option::is_none")]
1257    pub sku: Option<Sku>,
1258
1259    /// VMSS properties
1260    #[serde(skip_serializing_if = "Option::is_none")]
1261    pub properties: Option<VirtualMachineScaleSetProperties>,
1262}
1263
1264impl VirtualMachineScaleSet {
1265    #[cfg(any(test, feature = "test-support"))]
1266    /// Create a fixture instance for testing.
1267    pub fn fixture() -> Self {
1268        Self {
1269            id: Some("test-id".into()),
1270            name: Some("test-virtual_machine_scale_set".into()),
1271            r#type: Some("test-type".into()),
1272            location: Some("test-location".into()),
1273            tags: Default::default(),
1274            sku: Some(Sku::fixture()),
1275            properties: Some(VirtualMachineScaleSetProperties::fixture()),
1276        }
1277    }
1278}
1279
1280/// Response for listing virtual machine scale sets.
1281///
1282/// **Azure API**: `compute.v1.VirtualMachineScaleSetListResult`
1283/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetListResult>
1284#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1285#[serde(rename_all = "camelCase")]
1286pub struct VirtualMachineScaleSetListResult {
1287    /// List of virtual machine scale sets
1288    #[serde(default)]
1289    pub value: Vec<VirtualMachineScaleSet>,
1290
1291    /// URL to get the next page of results
1292    #[serde(skip_serializing_if = "Option::is_none")]
1293    pub next_link: Option<String>,
1294}
1295
1296impl VirtualMachineScaleSetListResult {
1297    #[cfg(any(test, feature = "test-support"))]
1298    /// Create a fixture instance for testing.
1299    pub fn fixture() -> Self {
1300        Self {
1301            value: vec![],
1302            next_link: Some("test-next_link".into()),
1303        }
1304    }
1305}
1306
1307/// Request body for creating or updating a virtual machine scale set.
1308///
1309/// **Azure API**: `compute.v1.VirtualMachineScaleSetCreateRequest`
1310/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetCreateRequest>
1311#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1312#[serde(rename_all = "camelCase")]
1313pub struct VirtualMachineScaleSetCreateRequest {
1314    /// Resource location
1315    pub location: String,
1316
1317    /// Resource tags
1318    #[serde(default)]
1319    #[serde(skip_serializing_if = "HashMap::is_empty")]
1320    pub tags: HashMap<String, String>,
1321
1322    /// VMSS SKU (VM size + capacity)
1323    #[serde(skip_serializing_if = "Option::is_none")]
1324    pub sku: Option<Sku>,
1325
1326    /// VMSS properties
1327    #[serde(skip_serializing_if = "Option::is_none")]
1328    pub properties: Option<VirtualMachineScaleSetProperties>,
1329}
1330
1331impl VirtualMachineScaleSetCreateRequest {
1332    #[cfg(any(test, feature = "test-support"))]
1333    /// Create a fixture instance for testing.
1334    pub fn fixture() -> Self {
1335        Self {
1336            location: "test-location".into(),
1337            tags: Default::default(),
1338            sku: Some(Sku::fixture()),
1339            properties: Some(VirtualMachineScaleSetProperties::fixture()),
1340        }
1341    }
1342}
1343
1344/// A virtual machine in a VM scale set.
1345///
1346/// **Azure API**: `compute.v1.VirtualMachineScaleSetVM`
1347/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetVM>
1348#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1349#[serde(rename_all = "camelCase")]
1350pub struct VirtualMachineScaleSetVM {
1351    /// Resource ID
1352    #[serde(skip_serializing_if = "Option::is_none")]
1353    pub id: Option<String>,
1354
1355    /// Resource name
1356    #[serde(skip_serializing_if = "Option::is_none")]
1357    pub name: Option<String>,
1358
1359    /// Resource type
1360    #[serde(rename = "type")]
1361    #[serde(skip_serializing_if = "Option::is_none")]
1362    pub r#type: Option<String>,
1363
1364    /// Resource location
1365    #[serde(skip_serializing_if = "Option::is_none")]
1366    pub location: Option<String>,
1367
1368    /// Instance ID within the scale set
1369    #[serde(skip_serializing_if = "Option::is_none")]
1370    pub instance_id: Option<String>,
1371
1372    /// VM SKU information
1373    #[serde(skip_serializing_if = "Option::is_none")]
1374    pub sku: Option<Sku>,
1375
1376    /// VMSS VM properties
1377    #[serde(skip_serializing_if = "Option::is_none")]
1378    pub properties: Option<VirtualMachineScaleSetVMProperties>,
1379}
1380
1381impl VirtualMachineScaleSetVM {
1382    #[cfg(any(test, feature = "test-support"))]
1383    /// Create a fixture instance for testing.
1384    pub fn fixture() -> Self {
1385        Self {
1386            id: Some("test-id".into()),
1387            name: Some("test-virtual_machine_scale_set_vm".into()),
1388            r#type: Some("test-type".into()),
1389            location: Some("test-location".into()),
1390            instance_id: Some("test-instance_id".into()),
1391            sku: Some(Sku::fixture()),
1392            properties: Some(VirtualMachineScaleSetVMProperties::fixture()),
1393        }
1394    }
1395}
1396
1397/// Properties of a VMSS VM instance.
1398///
1399/// **Azure API**: `compute.v1.VirtualMachineScaleSetVMProperties`
1400/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetVMProperties>
1401#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1402#[serde(rename_all = "camelCase")]
1403pub struct VirtualMachineScaleSetVMProperties {
1404    /// Whether the latest VMSS model is applied
1405    #[serde(skip_serializing_if = "Option::is_none")]
1406    pub latest_model_applied: Option<bool>,
1407
1408    /// Unique VM identifier
1409    #[serde(skip_serializing_if = "Option::is_none")]
1410    pub vm_id: Option<String>,
1411
1412    /// Provisioning state
1413    #[serde(skip_serializing_if = "Option::is_none")]
1414    pub provisioning_state: Option<String>,
1415
1416    /// Hardware profile (VM size)
1417    #[serde(skip_serializing_if = "Option::is_none")]
1418    pub hardware_profile: Option<HardwareProfile>,
1419
1420    /// Storage profile
1421    #[serde(skip_serializing_if = "Option::is_none")]
1422    pub storage_profile: Option<StorageProfile>,
1423
1424    /// OS profile
1425    #[serde(skip_serializing_if = "Option::is_none")]
1426    pub os_profile: Option<OsProfile>,
1427
1428    /// Network profile
1429    #[serde(skip_serializing_if = "Option::is_none")]
1430    pub network_profile: Option<NetworkProfile>,
1431}
1432
1433impl VirtualMachineScaleSetVMProperties {
1434    #[cfg(any(test, feature = "test-support"))]
1435    /// Create a fixture instance for testing.
1436    pub fn fixture() -> Self {
1437        Self {
1438            latest_model_applied: Some(false),
1439            vm_id: Some("test-vm_id".into()),
1440            provisioning_state: Some("test-provisioning_state".into()),
1441            hardware_profile: Some(HardwareProfile::fixture()),
1442            storage_profile: Some(StorageProfile::fixture()),
1443            os_profile: Some(OsProfile::fixture()),
1444            network_profile: Some(NetworkProfile::fixture()),
1445        }
1446    }
1447}
1448
1449/// Response for listing VMSS VM instances.
1450///
1451/// **Azure API**: `compute.v1.VirtualMachineScaleSetVMListResult`
1452/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetVMListResult>
1453#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1454#[serde(rename_all = "camelCase")]
1455pub struct VirtualMachineScaleSetVMListResult {
1456    /// List of VMSS VM instances
1457    #[serde(default)]
1458    pub value: Vec<VirtualMachineScaleSetVM>,
1459
1460    /// URL to get the next page of results
1461    #[serde(skip_serializing_if = "Option::is_none")]
1462    pub next_link: Option<String>,
1463}
1464
1465impl VirtualMachineScaleSetVMListResult {
1466    #[cfg(any(test, feature = "test-support"))]
1467    /// Create a fixture instance for testing.
1468    pub fn fixture() -> Self {
1469        Self {
1470            value: vec![],
1471            next_link: Some("test-next_link".into()),
1472        }
1473    }
1474}
1475
1476/// Instance IDs for VMSS instance operations.
1477///
1478/// **Azure API**: `compute.v1.VirtualMachineScaleSetVMInstanceIDs`
1479/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//VirtualMachineScaleSetVMInstanceIDs>
1480#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1481#[serde(rename_all = "camelCase")]
1482pub struct VirtualMachineScaleSetVMInstanceIDs {
1483    /// VM instance IDs (omit to target all instances)
1484    #[serde(default)]
1485    #[serde(skip_serializing_if = "Vec::is_empty")]
1486    pub instance_ids: Vec<String>,
1487}
1488
1489impl VirtualMachineScaleSetVMInstanceIDs {
1490    #[cfg(any(test, feature = "test-support"))]
1491    /// Create a fixture instance for testing.
1492    pub fn fixture() -> Self {
1493        Self {
1494            instance_ids: vec![],
1495        }
1496    }
1497}
1498
1499/// The disks sku name.
1500///
1501/// **Azure API**: `compute.v1.DiskSku`
1502/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//DiskSku>
1503#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1504#[serde(rename_all = "camelCase")]
1505pub struct DiskSku {
1506    /// The sku name (Standard_LRS, Premium_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS,
1507    /// StandardSSD_ZRS, PremiumV2_LRS)
1508    #[serde(skip_serializing_if = "Option::is_none")]
1509    pub name: Option<String>,
1510
1511    /// The sku tier
1512    #[serde(skip_serializing_if = "Option::is_none")]
1513    pub tier: Option<String>,
1514}
1515
1516impl DiskSku {
1517    #[cfg(any(test, feature = "test-support"))]
1518    /// Create a fixture instance for testing.
1519    pub fn fixture() -> Self {
1520        Self {
1521            name: Some("test-disk_sku".into()),
1522            tier: Some("test-tier".into()),
1523        }
1524    }
1525}
1526
1527/// Data used when creating a disk.
1528///
1529/// **Azure API**: `compute.v1.DiskCreationData`
1530/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//DiskCreationData>
1531#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1532#[serde(rename_all = "camelCase")]
1533pub struct DiskCreationData {
1534    /// Disk source type: Empty, Copy, Import, Restore, FromImage, etc.
1535    pub create_option: String,
1536
1537    /// Storage account ID (required for Import)
1538    #[serde(skip_serializing_if = "Option::is_none")]
1539    pub storage_account_id: Option<String>,
1540
1541    /// URI of source VHD (for Import)
1542    #[serde(skip_serializing_if = "Option::is_none")]
1543    pub source_uri: Option<String>,
1544
1545    /// ARM ID of source snapshot or disk (for Copy)
1546    #[serde(skip_serializing_if = "Option::is_none")]
1547    pub source_resource_id: Option<String>,
1548
1549    /// Disk image reference (for FromImage)
1550    #[serde(skip_serializing_if = "Option::is_none")]
1551    pub image_reference: Option<ImageDiskReference>,
1552
1553    /// Gallery image reference (for FromImage)
1554    #[serde(skip_serializing_if = "Option::is_none")]
1555    pub gallery_image_reference: Option<ImageDiskReference>,
1556}
1557
1558impl DiskCreationData {
1559    #[cfg(any(test, feature = "test-support"))]
1560    /// Create a fixture instance for testing.
1561    pub fn fixture() -> Self {
1562        Self {
1563            create_option: "test-create_option".into(),
1564            storage_account_id: Some("test-storage_account_id".into()),
1565            source_uri: Some("test-source_uri".into()),
1566            source_resource_id: Some("test-source_resource_id".into()),
1567            image_reference: Some(ImageDiskReference::fixture()),
1568            gallery_image_reference: Some(ImageDiskReference::fixture()),
1569        }
1570    }
1571}
1572
1573/// The source image used for creating the disk.
1574///
1575/// **Azure API**: `compute.v1.ImageDiskReference`
1576/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//ImageDiskReference>
1577#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1578#[serde(rename_all = "camelCase")]
1579pub struct ImageDiskReference {
1580    /// ARM ID of the image or gallery image version
1581    #[serde(skip_serializing_if = "Option::is_none")]
1582    pub id: Option<String>,
1583
1584    /// If the disk is created from an image's data disk, this is an index into the data disk
1585    /// array
1586    #[serde(skip_serializing_if = "Option::is_none")]
1587    pub lun: Option<i32>,
1588}
1589
1590impl ImageDiskReference {
1591    #[cfg(any(test, feature = "test-support"))]
1592    /// Create a fixture instance for testing.
1593    pub fn fixture() -> Self {
1594        Self {
1595            id: Some("test-id".into()),
1596            lun: Some(100),
1597        }
1598    }
1599}
1600
1601/// Disk resource properties.
1602///
1603/// **Azure API**: `compute.v1.DiskProperties`
1604/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//DiskProperties>
1605#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1606#[serde(rename_all = "camelCase")]
1607pub struct DiskProperties {
1608    /// The disk provisioning state
1609    #[serde(skip_serializing_if = "Option::is_none")]
1610    pub provisioning_state: Option<String>,
1611
1612    /// The state of the disk (Unattached, Attached, Reserved, Frozen, etc.)
1613    #[serde(skip_serializing_if = "Option::is_none")]
1614    pub disk_state: Option<String>,
1615
1616    /// Disk size in GB
1617    #[serde(rename = "diskSizeGB")]
1618    #[serde(skip_serializing_if = "Option::is_none")]
1619    pub disk_size_gb: Option<i32>,
1620
1621    /// The size of the disk in bytes
1622    #[serde(rename = "diskSizeBytes")]
1623    #[serde(skip_serializing_if = "Option::is_none")]
1624    pub disk_size_bytes: Option<i64>,
1625
1626    /// The number of IOPS allowed for this disk (UltraSSD only)
1627    #[serde(rename = "diskIOPSReadWrite")]
1628    #[serde(skip_serializing_if = "Option::is_none")]
1629    pub disk_iops_read_write: Option<i64>,
1630
1631    /// The bandwidth allowed for this disk in MB per second (UltraSSD only)
1632    #[serde(rename = "diskMBpsReadWrite")]
1633    #[serde(skip_serializing_if = "Option::is_none")]
1634    pub disk_m_bps_read_write: Option<i64>,
1635
1636    /// The operating system type (Windows or Linux)
1637    #[serde(skip_serializing_if = "Option::is_none")]
1638    pub os_type: Option<String>,
1639
1640    /// The hypervisor generation of the VM (V1 or V2)
1641    #[serde(skip_serializing_if = "Option::is_none")]
1642    pub hyper_v_generation: Option<String>,
1643
1644    /// Disk source information
1645    #[serde(skip_serializing_if = "Option::is_none")]
1646    pub creation_data: Option<DiskCreationData>,
1647
1648    /// Encryption settings collection for Azure Disk Encryption
1649    #[serde(skip_serializing_if = "Option::is_none")]
1650    pub encryption_settings_collection: Option<EncryptionSettingsCollection>,
1651
1652    /// Encryption property to encrypt data using customer managed or platform managed keys
1653    #[serde(skip_serializing_if = "Option::is_none")]
1654    pub encryption: Option<Encryption>,
1655
1656    /// Policy for accessing the disk via network (AllowAll, AllowPrivate, DenyAll)
1657    #[serde(skip_serializing_if = "Option::is_none")]
1658    pub network_access_policy: Option<String>,
1659
1660    /// Policy for controlling export on the disk (Enabled, Disabled)
1661    #[serde(skip_serializing_if = "Option::is_none")]
1662    pub public_network_access: Option<String>,
1663
1664    /// The time when the disk was created
1665    #[serde(skip_serializing_if = "Option::is_none")]
1666    pub time_created: Option<String>,
1667
1668    /// Unique GUID identifying the resource
1669    #[serde(skip_serializing_if = "Option::is_none")]
1670    pub unique_id: Option<String>,
1671}
1672
1673impl DiskProperties {
1674    #[cfg(any(test, feature = "test-support"))]
1675    /// Create a fixture instance for testing.
1676    pub fn fixture() -> Self {
1677        Self {
1678            provisioning_state: Some("test-provisioning_state".into()),
1679            disk_state: Some("test-disk_state".into()),
1680            disk_size_gb: Some(100),
1681            disk_size_bytes: Some(100),
1682            disk_iops_read_write: Some(100),
1683            disk_m_bps_read_write: Some(100),
1684            os_type: Some("test-os_type".into()),
1685            hyper_v_generation: Some("test-hyper_v_generation".into()),
1686            creation_data: Some(DiskCreationData::fixture()),
1687            encryption_settings_collection: Some(EncryptionSettingsCollection::fixture()),
1688            encryption: Some(Encryption::fixture()),
1689            network_access_policy: Some("test-network_access_policy".into()),
1690            public_network_access: Some("test-public_network_access".into()),
1691            time_created: Some("test-time_created".into()),
1692            unique_id: Some("test-unique_id".into()),
1693        }
1694    }
1695}
1696
1697/// Encryption settings for disk or snapshot.
1698///
1699/// **Azure API**: `compute.v1.EncryptionSettingsCollection`
1700/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//EncryptionSettingsCollection>
1701#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1702#[serde(rename_all = "camelCase")]
1703pub struct EncryptionSettingsCollection {
1704    /// Whether encryption settings are enabled
1705    #[serde(default)]
1706    pub enabled: bool,
1707
1708    /// A collection of encryption settings, one for each disk volume
1709    #[serde(default)]
1710    #[serde(skip_serializing_if = "Vec::is_empty")]
1711    pub encryption_settings: Vec<EncryptionSettingsElement>,
1712}
1713
1714impl EncryptionSettingsCollection {
1715    #[cfg(any(test, feature = "test-support"))]
1716    /// Create a fixture instance for testing.
1717    pub fn fixture() -> Self {
1718        Self {
1719            enabled: false,
1720            encryption_settings: vec![],
1721        }
1722    }
1723}
1724
1725/// Encryption settings for one disk volume.
1726///
1727/// **Azure API**: `compute.v1.EncryptionSettingsElement`
1728/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//EncryptionSettingsElement>
1729#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1730#[serde(rename_all = "camelCase")]
1731pub struct EncryptionSettingsElement {
1732    /// Key Vault Secret URL and vault id of the disk encryption key
1733    #[serde(skip_serializing_if = "Option::is_none")]
1734    pub disk_encryption_key: Option<KeyVaultAndSecretReference>,
1735
1736    /// Key Vault Key URL and vault id of the key encryption key
1737    #[serde(skip_serializing_if = "Option::is_none")]
1738    pub key_encryption_key: Option<KeyVaultAndKeyReference>,
1739}
1740
1741impl EncryptionSettingsElement {
1742    #[cfg(any(test, feature = "test-support"))]
1743    /// Create a fixture instance for testing.
1744    pub fn fixture() -> Self {
1745        Self {
1746            disk_encryption_key: Some(KeyVaultAndSecretReference::fixture()),
1747            key_encryption_key: Some(KeyVaultAndKeyReference::fixture()),
1748        }
1749    }
1750}
1751
1752/// Key Vault Secret URL and vault id of the encryption key.
1753///
1754/// **Azure API**: `compute.v1.KeyVaultAndSecretReference`
1755/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//KeyVaultAndSecretReference>
1756#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1757#[serde(rename_all = "camelCase")]
1758pub struct KeyVaultAndSecretReference {
1759    /// Resource id of the KeyVault containing the key or secret
1760    pub source_vault: SubResource,
1761
1762    /// Url pointing to a key or secret in KeyVault
1763    pub secret_url: String,
1764}
1765
1766impl KeyVaultAndSecretReference {
1767    #[cfg(any(test, feature = "test-support"))]
1768    /// Create a fixture instance for testing.
1769    pub fn fixture() -> Self {
1770        Self {
1771            source_vault: SubResource::fixture(),
1772            secret_url: "test-secret_url".into(),
1773        }
1774    }
1775}
1776
1777/// Key Vault Key URL and vault id of the encryption key.
1778///
1779/// **Azure API**: `compute.v1.KeyVaultAndKeyReference`
1780/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//KeyVaultAndKeyReference>
1781#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1782#[serde(rename_all = "camelCase")]
1783pub struct KeyVaultAndKeyReference {
1784    /// Resource id of the KeyVault containing the key or secret
1785    pub source_vault: SubResource,
1786
1787    /// Url pointing to a key or secret in KeyVault
1788    pub key_url: String,
1789}
1790
1791impl KeyVaultAndKeyReference {
1792    #[cfg(any(test, feature = "test-support"))]
1793    /// Create a fixture instance for testing.
1794    pub fn fixture() -> Self {
1795        Self {
1796            source_vault: SubResource::fixture(),
1797            key_url: "test-key_url".into(),
1798        }
1799    }
1800}
1801
1802/// Encryption at rest settings for disk or snapshot.
1803///
1804/// **Azure API**: `compute.v1.Encryption`
1805/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//Encryption>
1806#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1807#[serde(rename_all = "camelCase")]
1808pub struct Encryption {
1809    /// ResourceId of the disk encryption set to use for enabling encryption at rest
1810    #[serde(skip_serializing_if = "Option::is_none")]
1811    pub disk_encryption_set_id: Option<String>,
1812
1813    /// The type of key used to encrypt the data of the disk (EncryptionAtRestWithPlatformKey,
1814    /// EncryptionAtRestWithCustomerKey, etc.)
1815    #[serde(rename = "type")]
1816    #[serde(skip_serializing_if = "Option::is_none")]
1817    pub r#type: Option<String>,
1818}
1819
1820impl Encryption {
1821    #[cfg(any(test, feature = "test-support"))]
1822    /// Create a fixture instance for testing.
1823    pub fn fixture() -> Self {
1824        Self {
1825            disk_encryption_set_id: Some("test-disk_encryption_set_id".into()),
1826            r#type: Some("test-type".into()),
1827        }
1828    }
1829}
1830
1831/// Disk resource.
1832///
1833/// **Azure API**: `compute.v1.Disk`
1834/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//Disk>
1835#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1836#[serde(rename_all = "camelCase")]
1837pub struct Disk {
1838    /// Resource ID
1839    #[serde(skip_serializing_if = "Option::is_none")]
1840    pub id: Option<String>,
1841
1842    /// Resource name
1843    #[serde(skip_serializing_if = "Option::is_none")]
1844    pub name: Option<String>,
1845
1846    /// Resource type
1847    #[serde(rename = "type")]
1848    #[serde(skip_serializing_if = "Option::is_none")]
1849    pub r#type: Option<String>,
1850
1851    /// Resource location
1852    pub location: String,
1853
1854    /// Resource tags
1855    #[serde(default)]
1856    #[serde(skip_serializing_if = "HashMap::is_empty")]
1857    pub tags: HashMap<String, String>,
1858
1859    /// The logical zone list for Disk
1860    #[serde(default)]
1861    #[serde(skip_serializing_if = "Vec::is_empty")]
1862    pub zones: Vec<String>,
1863
1864    /// The disks sku name
1865    #[serde(skip_serializing_if = "Option::is_none")]
1866    pub sku: Option<DiskSku>,
1867
1868    /// Disk resource properties
1869    #[serde(skip_serializing_if = "Option::is_none")]
1870    pub properties: Option<DiskProperties>,
1871}
1872
1873impl Disk {
1874    #[cfg(any(test, feature = "test-support"))]
1875    /// Create a fixture instance for testing.
1876    pub fn fixture() -> Self {
1877        Self {
1878            id: Some("test-id".into()),
1879            name: Some("test-disk".into()),
1880            r#type: Some("test-type".into()),
1881            location: "test-location".into(),
1882            tags: Default::default(),
1883            zones: vec![],
1884            sku: Some(DiskSku::fixture()),
1885            properties: Some(DiskProperties::fixture()),
1886        }
1887    }
1888}
1889
1890/// The List Disks operation response.
1891///
1892/// **Azure API**: `compute.v1.DiskListResult`
1893/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//DiskListResult>
1894#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1895#[serde(rename_all = "camelCase")]
1896pub struct DiskListResult {
1897    /// A list of disks
1898    #[serde(default)]
1899    pub value: Vec<Disk>,
1900
1901    /// The uri to fetch the next page of disks
1902    #[serde(skip_serializing_if = "Option::is_none")]
1903    pub next_link: Option<String>,
1904}
1905
1906impl DiskListResult {
1907    #[cfg(any(test, feature = "test-support"))]
1908    /// Create a fixture instance for testing.
1909    pub fn fixture() -> Self {
1910        Self {
1911            value: vec![],
1912            next_link: Some("test-next_link".into()),
1913        }
1914    }
1915}
1916
1917/// Request body for creating or updating a disk.
1918///
1919/// **Azure API**: `compute.v1.DiskCreateRequest`
1920/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//DiskCreateRequest>
1921#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1922#[serde(rename_all = "camelCase")]
1923pub struct DiskCreateRequest {
1924    /// Resource location
1925    pub location: String,
1926
1927    /// Resource tags
1928    #[serde(default)]
1929    #[serde(skip_serializing_if = "HashMap::is_empty")]
1930    pub tags: HashMap<String, String>,
1931
1932    /// The logical zone list for Disk
1933    #[serde(default)]
1934    #[serde(skip_serializing_if = "Vec::is_empty")]
1935    pub zones: Vec<String>,
1936
1937    /// The disks sku name
1938    #[serde(skip_serializing_if = "Option::is_none")]
1939    pub sku: Option<DiskSku>,
1940
1941    /// Disk resource properties
1942    #[serde(skip_serializing_if = "Option::is_none")]
1943    pub properties: Option<DiskProperties>,
1944}
1945
1946impl DiskCreateRequest {
1947    #[cfg(any(test, feature = "test-support"))]
1948    /// Create a fixture instance for testing.
1949    pub fn fixture() -> Self {
1950        Self {
1951            location: "test-location".into(),
1952            tags: Default::default(),
1953            zones: vec![],
1954            sku: Some(DiskSku::fixture()),
1955            properties: Some(DiskProperties::fixture()),
1956        }
1957    }
1958}
1959
1960/// Request body for updating a disk (PATCH).
1961///
1962/// **Azure API**: `compute.v1.DiskUpdateRequest`
1963/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//DiskUpdateRequest>
1964#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1965#[serde(rename_all = "camelCase")]
1966pub struct DiskUpdateRequest {
1967    /// Resource tags
1968    #[serde(default)]
1969    #[serde(skip_serializing_if = "HashMap::is_empty")]
1970    pub tags: HashMap<String, String>,
1971
1972    /// The disk SKU (name and tier)
1973    #[serde(skip_serializing_if = "Option::is_none")]
1974    pub sku: Option<DiskSku>,
1975}
1976
1977impl DiskUpdateRequest {
1978    #[cfg(any(test, feature = "test-support"))]
1979    /// Create a fixture instance for testing.
1980    pub fn fixture() -> Self {
1981        Self {
1982            tags: Default::default(),
1983            sku: Some(DiskSku::fixture()),
1984        }
1985    }
1986}
1987
1988/// Data used for requesting a SAS URI for a managed disk or snapshot.
1989///
1990/// **Azure API**: `compute.v1.GrantAccessData`
1991/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//GrantAccessData>
1992#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1993#[serde(rename_all = "camelCase")]
1994pub struct GrantAccessData {
1995    /// The Access Level (None, Read, Write)
1996    pub access: String,
1997
1998    /// Time duration in seconds until the SAS access expires
1999    pub duration_in_seconds: i32,
2000
2001    /// Used to specify the file format when downloading a VHD snapshot (VHDX or VHD)
2002    #[serde(skip_serializing_if = "Option::is_none")]
2003    pub file_format: Option<String>,
2004}
2005
2006impl GrantAccessData {
2007    #[cfg(any(test, feature = "test-support"))]
2008    /// Create a fixture instance for testing.
2009    pub fn fixture() -> Self {
2010        Self {
2011            access: "test-access".into(),
2012            duration_in_seconds: 100,
2013            file_format: Some("test-file_format".into()),
2014        }
2015    }
2016}
2017
2018/// A disk access SAS uri.
2019///
2020/// **Azure API**: `compute.v1.AccessUri`
2021/// **Reference**: <https://learn.microsoft.com/en-us/rest/api/compute//AccessUri>
2022#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2023#[serde(rename_all = "camelCase")]
2024pub struct AccessUri {
2025    /// A SAS uri for accessing a disk
2026    #[serde(rename = "accessSAS")]
2027    #[serde(skip_serializing_if = "Option::is_none")]
2028    pub access_sas: Option<String>,
2029
2030    /// A SAS uri for accessing a VM guest state
2031    #[serde(rename = "securityDataAccessSAS")]
2032    #[serde(skip_serializing_if = "Option::is_none")]
2033    pub security_data_access_sas: Option<String>,
2034}
2035
2036impl AccessUri {
2037    #[cfg(any(test, feature = "test-support"))]
2038    /// Create a fixture instance for testing.
2039    pub fn fixture() -> Self {
2040        Self {
2041            access_sas: Some("test-access_sas".into()),
2042            security_data_access_sas: Some("test-security_data_access_sas".into()),
2043        }
2044    }
2045}
azure_lite_rs/types/compute.rs

azure_lite_rs/types/
compute.rs
