@azure/arm-computeschedule 1.2.0-beta.1 → 2.0.0-beta.1

package/dist/browser/models/models.js

@@ -133,14 +133,32 @@ export function retryPolicySerializer(item) {
     return {
         retryCount: item["retryCount"],
         retryWindowInMinutes: item["retryWindowInMinutes"],
+        onFailureAction: item["onFailureAction"],
     };
 }
 export function retryPolicyDeserializer(item) {
     return {
         retryCount: item["retryCount"],
         retryWindowInMinutes: item["retryWindowInMinutes"],
+        onFailureAction: item["onFailureAction"],
     };
 }
+/** The kind of operation types that can be performed on resources using ScheduledActions */
+export var KnownResourceOperationType;
+(function (KnownResourceOperationType) {
+    /** The default value for this enum type */
+    KnownResourceOperationType["Unknown"] = "Unknown";
+    /** Start operations on the resources */
+    KnownResourceOperationType["Start"] = "Start";
+    /** Deallocate operations on the resources */
+    KnownResourceOperationType["Deallocate"] = "Deallocate";
+    /** Hibernate operations on the resources */
+    KnownResourceOperationType["Hibernate"] = "Hibernate";
+    /** Create operations on the resources */
+    KnownResourceOperationType["Create"] = "Create";
+    /** Delete operations on the resources */
+    KnownResourceOperationType["Delete"] = "Delete";
+})(KnownResourceOperationType || (KnownResourceOperationType = {}));
 export function resourcesSerializer(item) {
     return {
         ids: item["ids"].map((p) => {
@@ -187,24 +205,15 @@ export function resourceOperationDetailsDeserializer(item) {
         resourceOperationError: !item["resourceOperationError"]
             ? item["resourceOperationError"]
             : resourceOperationErrorDeserializer(item["resourceOperationError"]),
+        fallbackOperationInfo: !item["fallbackOperationInfo"]
+            ? item["fallbackOperationInfo"]
+            : fallbackOperationInfoDeserializer(item["fallbackOperationInfo"]),
         completedAt: item["completedAt"],
         retryPolicy: !item["retryPolicy"]
             ? item["retryPolicy"]
             : retryPolicyDeserializer(item["retryPolicy"]),
     };
 }
-/** The kind of operation types that can be performed on resources using ScheduledActions */
-export var KnownResourceOperationType;
-(function (KnownResourceOperationType) {
-    /** The default value for this enum type */
-    KnownResourceOperationType["Unknown"] = "Unknown";
-    /** Start operations on the resources */
-    KnownResourceOperationType["Start"] = "Start";
-    /** Deallocate operations on the resources */
-    KnownResourceOperationType["Deallocate"] = "Deallocate";
-    /** Hibernate operations on the resources */
-    KnownResourceOperationType["Hibernate"] = "Hibernate";
-})(KnownResourceOperationType || (KnownResourceOperationType = {}));
 /** Values that define the states of operations in Scheduled Actions */
 export var KnownOperationState;
 (function (KnownOperationState) {
@@ -233,6 +242,13 @@ export function resourceOperationErrorDeserializer(item) {
         errorDetails: item["errorDetails"],
     };
 }
+export function fallbackOperationInfoDeserializer(item) {
+    return {
+        lastOpType: item["lastOpType"],
+        status: item["status"],
+        error: !item["error"] ? item["error"] : resourceOperationErrorDeserializer(item["error"]),
+    };
+}
 export function submitHibernateRequestSerializer(item) {
     return {
         schedule: scheduleSerializer(item["schedule"]),
@@ -290,21 +306,1131 @@ export function executeStartRequestSerializer(item) {
         correlationid: item["correlationId"],
     };
 }
+export function executeCreateFlexRequestSerializer(item) {
+    return {
+        resourceConfigParameters: resourceProvisionFlexPayloadSerializer(item["resourceConfigParameters"]),
+        executionParameters: executionParametersSerializer(item["executionParameters"]),
+        correlationid: item["correlationId"],
+    };
+}
+export function resourceProvisionFlexPayloadSerializer(item) {
+    return {
+        virtualMachineBaseProfile: !item["virtualMachineBaseProfile"]
+            ? item["virtualMachineBaseProfile"]
+            : bulkVMConfigurationSerializer(item["virtualMachineBaseProfile"]),
+        virtualMachineOverrides: !item["virtualMachineOverrides"]
+            ? item["virtualMachineOverrides"]
+            : bulkVMConfigurationArraySerializer(item["virtualMachineOverrides"]),
+        resourceCount: item["resourceCount"],
+        resourcePrefix: item["resourcePrefix"],
+        flexProperties: flexPropertiesSerializer(item["flexProperties"]),
+    };
+}
+export function bulkVMConfigurationSerializer(item) {
+    return {
+        name: item["name"],
+        computeApiVersion: item["computeApiVersion"] ?? "2026-04-15-preview",
+        resourceGroupName: item["resourceGroupName"],
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+        plan: !item["plan"] ? item["plan"] : planSerializer(item["plan"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : virtualMachineIdentitySerializer(item["identity"]),
+        extendedLocation: !item["extendedLocation"]
+            ? item["extendedLocation"]
+            : extendedLocationSerializer(item["extendedLocation"]),
+        placement: !item["placement"] ? item["placement"] : placementSerializer(item["placement"]),
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : bulkActionVMPropertiesSerializer(item["properties"]),
+        vmExtensions: !item["vmExtensions"]
+            ? item["vmExtensions"]
+            : bulkActionVMExtensionArraySerializer(item["vmExtensions"]),
+    };
+}
+export function planSerializer(item) {
+    return {
+        name: item["name"],
+        publisher: item["publisher"],
+        product: item["product"],
+        promotionCode: item["promotionCode"],
+        version: item["version"],
+    };
+}
+export function virtualMachineIdentitySerializer(item) {
+    return {
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentitiesValueRecordSerializer(item["userAssignedIdentities"]),
+    };
+}
+export function userAssignedIdentitiesValueRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentitiesValueSerializer(item[key]);
+    });
+    return result;
+}
+export function userAssignedIdentitiesValueSerializer(_item) {
+    return {};
+}
+export function extendedLocationSerializer(item) {
+    return { name: item["name"], type: item["type"] };
+}
+/** The supported ExtendedLocation types. */
+export var KnownExtendedLocationType;
+(function (KnownExtendedLocationType) {
+    /** Azure Edge Zones location type */
+    KnownExtendedLocationType["EdgeZone"] = "EdgeZone";
+    /** Azure Custom Locations type */
+    KnownExtendedLocationType["CustomLocation"] = "CustomLocation";
+})(KnownExtendedLocationType || (KnownExtendedLocationType = {}));
+export function placementSerializer(item) {
+    return {
+        zonePlacementPolicy: item["zonePlacementPolicy"],
+        includeZones: !item["includeZones"]
+            ? item["includeZones"]
+            : item["includeZones"].map((p) => {
+                return p;
+            }),
+        excludeZones: !item["excludeZones"]
+            ? item["excludeZones"]
+            : item["excludeZones"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** Specifies the policy for resource's placement in availability zone. Possible values are: **Any** (used for Virtual Machines), **Auto** (used for Virtual Machine Scale Sets) - An availability zone will be automatically picked by system as part of resource creation. */
+export var KnownZonePlacementPolicyType;
+(function (KnownZonePlacementPolicyType) {
+    /** Any */
+    KnownZonePlacementPolicyType["Any"] = "Any";
+    /** The platform automatically selects an availability zone based on the request. */
+    KnownZonePlacementPolicyType["Auto"] = "Auto";
+})(KnownZonePlacementPolicyType || (KnownZonePlacementPolicyType = {}));
+export function bulkActionVMPropertiesSerializer(item) {
+    return {
+        scheduledEventsPolicy: !item["scheduledEventsPolicy"]
+            ? item["scheduledEventsPolicy"]
+            : scheduledEventsPolicySerializer(item["scheduledEventsPolicy"]),
+        storageProfile: !item["storageProfile"]
+            ? item["storageProfile"]
+            : storageProfileSerializer(item["storageProfile"]),
+        additionalCapabilities: !item["additionalCapabilities"]
+            ? item["additionalCapabilities"]
+            : additionalCapabilitiesSerializer(item["additionalCapabilities"]),
+        osProfile: !item["osProfile"] ? item["osProfile"] : osProfileSerializer(item["osProfile"]),
+        networkProfile: !item["networkProfile"]
+            ? item["networkProfile"]
+            : networkProfileSerializer(item["networkProfile"]),
+        hardwareProfile: !item["hardwareProfile"]
+            ? item["hardwareProfile"]
+            : hardwareProfileSerializer(item["hardwareProfile"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : securityProfileSerializer(item["securityProfile"]),
+        diagnosticsProfile: !item["diagnosticsProfile"]
+            ? item["diagnosticsProfile"]
+            : diagnosticsProfileSerializer(item["diagnosticsProfile"]),
+        licenseType: item["licenseType"],
+        extensionsTimeBudget: item["extensionsTimeBudget"],
+        scheduledEventsProfile: !item["scheduledEventsProfile"]
+            ? item["scheduledEventsProfile"]
+            : scheduledEventsProfileSerializer(item["scheduledEventsProfile"]),
+        userData: item["userData"],
+        capacityReservation: !item["capacityReservation"]
+            ? item["capacityReservation"]
+            : capacityReservationProfileSerializer(item["capacityReservation"]),
+        applicationProfile: !item["applicationProfile"]
+            ? item["applicationProfile"]
+            : applicationProfileSerializer(item["applicationProfile"]),
+    };
+}
+export function scheduledEventsPolicySerializer(item) {
+    return {
+        userInitiatedRedeploy: !item["userInitiatedRedeploy"]
+            ? item["userInitiatedRedeploy"]
+            : userInitiatedRedeploySerializer(item["userInitiatedRedeploy"]),
+        userInitiatedReboot: !item["userInitiatedReboot"]
+            ? item["userInitiatedReboot"]
+            : userInitiatedRebootSerializer(item["userInitiatedReboot"]),
+        scheduledEventsAdditionalPublishingTargets: !item["scheduledEventsAdditionalPublishingTargets"]
+            ? item["scheduledEventsAdditionalPublishingTargets"]
+            : scheduledEventsAdditionalPublishingTargetsSerializer(item["scheduledEventsAdditionalPublishingTargets"]),
+        allInstancesDown: !item["allInstancesDown"]
+            ? item["allInstancesDown"]
+            : allInstancesDownSerializer(item["allInstancesDown"]),
+    };
+}
+export function userInitiatedRedeploySerializer(item) {
+    return { automaticallyApprove: item["automaticallyApprove"] };
+}
+export function userInitiatedRebootSerializer(item) {
+    return { automaticallyApprove: item["automaticallyApprove"] };
+}
+export function scheduledEventsAdditionalPublishingTargetsSerializer(item) {
+    return {
+        eventGridAndResourceGraph: !item["eventGridAndResourceGraph"]
+            ? item["eventGridAndResourceGraph"]
+            : eventGridAndResourceGraphSerializer(item["eventGridAndResourceGraph"]),
+    };
+}
+export function eventGridAndResourceGraphSerializer(item) {
+    return {
+        enable: item["enable"],
+        scheduledEventsApiVersion: item["scheduledEventsApiVersion"] ?? "2026-04-15-preview",
+    };
+}
+export function allInstancesDownSerializer(item) {
+    return { automaticallyApprove: item["automaticallyApprove"] };
+}
+export function storageProfileSerializer(item) {
+    return {
+        imageReference: !item["imageReference"]
+            ? item["imageReference"]
+            : imageReferenceSerializer(item["imageReference"]),
+        osDisk: !item["osDisk"] ? item["osDisk"] : osDiskSerializer(item["osDisk"]),
+        dataDisks: !item["dataDisks"] ? item["dataDisks"] : dataDiskArraySerializer(item["dataDisks"]),
+        diskControllerType: item["diskControllerType"],
+    };
+}
+export function imageReferenceSerializer(item) {
+    return {
+        id: item["id"],
+        publisher: item["publisher"],
+        offer: item["offer"],
+        sku: item["sku"],
+        version: item["version"],
+        sharedGalleryImageId: item["sharedGalleryImageId"],
+        communityGalleryImageId: item["communityGalleryImageId"],
+    };
+}
+export function osDiskSerializer(item) {
+    return {
+        osType: item["osType"],
+        encryptionSettings: !item["encryptionSettings"]
+            ? item["encryptionSettings"]
+            : diskEncryptionSettingsSerializer(item["encryptionSettings"]),
+        name: item["name"],
+        vhd: !item["vhd"] ? item["vhd"] : virtualHardDiskSerializer(item["vhd"]),
+        image: !item["image"] ? item["image"] : virtualHardDiskSerializer(item["image"]),
+        caching: item["caching"],
+        writeAcceleratorEnabled: item["writeAcceleratorEnabled"],
+        diffDiskSettings: !item["diffDiskSettings"]
+            ? item["diffDiskSettings"]
+            : diffDiskSettingsSerializer(item["diffDiskSettings"]),
+        createOption: item["createOption"],
+        diskSizeGB: item["diskSizeGB"],
+        managedDisk: !item["managedDisk"]
+            ? item["managedDisk"]
+            : managedDiskParametersSerializer(item["managedDisk"]),
+        deleteOption: item["deleteOption"],
+    };
+}
+/** This property allows you to specify the supported type of the OS that application is built for. Possible values are: **Windows,** **Linux.** */
+export var KnownOperatingSystemTypes;
+(function (KnownOperatingSystemTypes) {
+    /** Windows OS */
+    KnownOperatingSystemTypes["Windows"] = "Windows";
+    /** Linux OS */
+    KnownOperatingSystemTypes["Linux"] = "Linux";
+})(KnownOperatingSystemTypes || (KnownOperatingSystemTypes = {}));
+export function diskEncryptionSettingsSerializer(item) {
+    return {
+        diskEncryptionKey: !item["diskEncryptionKey"]
+            ? item["diskEncryptionKey"]
+            : keyVaultSecretReferenceSerializer(item["diskEncryptionKey"]),
+        keyEncryptionKey: !item["keyEncryptionKey"]
+            ? item["keyEncryptionKey"]
+            : keyVaultKeyReferenceSerializer(item["keyEncryptionKey"]),
+        enabled: item["enabled"],
+    };
+}
+export function keyVaultSecretReferenceSerializer(item) {
+    return { secretUrl: item["secretUrl"], sourceVault: subResourceSerializer(item["sourceVault"]) };
+}
+export function subResourceSerializer(item) {
+    return { id: item["id"] };
+}
+export function keyVaultKeyReferenceSerializer(item) {
+    return { keyUrl: item["keyUrl"], sourceVault: subResourceSerializer(item["sourceVault"]) };
+}
+export function virtualHardDiskSerializer(item) {
+    return { uri: item["uri"] };
+}
+/** Specifies the caching requirements. Possible values are: **None,** **ReadOnly,** **ReadWrite.** The default values are: **None for Standard storage. ReadOnly for Premium storage** */
+export var KnownCachingTypes;
+(function (KnownCachingTypes) {
+    /** Caching type:None */
+    KnownCachingTypes["None"] = "None";
+    /** Caching type:ReadOnly */
+    KnownCachingTypes["ReadOnly"] = "ReadOnly";
+    /** Caching type:ReadWrite */
+    KnownCachingTypes["ReadWrite"] = "ReadWrite";
+})(KnownCachingTypes || (KnownCachingTypes = {}));
+export function diffDiskSettingsSerializer(item) {
+    return { option: item["option"], placement: item["placement"] };
+}
+/** Specifies the ephemeral disk option for operating system disk. */
+export var KnownDiffDiskOptions;
+(function (KnownDiffDiskOptions) {
+    /** Local Ephemeral disk option: Local */
+    KnownDiffDiskOptions["Local"] = "Local";
+})(KnownDiffDiskOptions || (KnownDiffDiskOptions = {}));
+/** Specifies the ephemeral disk placement for operating system disk. This property can be used by user in the request to choose the location i.e, cache disk, resource disk or nvme disk space for Ephemeral OS disk provisioning. For more information on Ephemeral OS disk size requirements, please refer Ephemeral OS disk size requirements for Windows VM at https://docs.microsoft.com/azure/virtual-machines/windows/ephemeral-os-disks#size-requirements and Linux VM at https://docs.microsoft.com/azure/virtual-machines/linux/ephemeral-os-disks#size-requirements. Minimum api-version for NvmeDisk: 2024-03-01. */
+export var KnownDiffDiskPlacement;
+(function (KnownDiffDiskPlacement) {
+    /** CacheDisk disk placement */
+    KnownDiffDiskPlacement["CacheDisk"] = "CacheDisk";
+    /** ResourceDisk disk placement */
+    KnownDiffDiskPlacement["ResourceDisk"] = "ResourceDisk";
+    /** NvmeDisk disk placement */
+    KnownDiffDiskPlacement["NvmeDisk"] = "NvmeDisk";
+})(KnownDiffDiskPlacement || (KnownDiffDiskPlacement = {}));
+/** Specifies how the virtual machine disk should be created. Possible values are **Attach:** This value is used when you are using a specialized disk to create the virtual machine. **FromImage:** This value is used when you are using an image to create the virtual machine. If you are using a platform image, you should also use the imageReference element described above. If you are using a marketplace image, you should also use the plan element previously described. **Empty:** This value is used when creating an empty data disk. **Copy:** This value is used to create a data disk from a snapshot or another disk. **Restore:** This value is used to create a data disk from a disk restore point. */
+export var KnownDiskCreateOptionTypes;
+(function (KnownDiskCreateOptionTypes) {
+    /** Create disk FromImage */
+    KnownDiskCreateOptionTypes["FromImage"] = "FromImage";
+    /** Empty value */
+    KnownDiskCreateOptionTypes["Empty"] = "Empty";
+    /** Create disk by Attach */
+    KnownDiskCreateOptionTypes["Attach"] = "Attach";
+    /** Create disk by Copy */
+    KnownDiskCreateOptionTypes["Copy"] = "Copy";
+    /** Create disk by Restore */
+    KnownDiskCreateOptionTypes["Restore"] = "Restore";
+})(KnownDiskCreateOptionTypes || (KnownDiskCreateOptionTypes = {}));
+export function managedDiskParametersSerializer(item) {
+    return {
+        id: item["id"],
+        storageAccountType: item["storageAccountType"],
+        diskEncryptionSet: !item["diskEncryptionSet"]
+            ? item["diskEncryptionSet"]
+            : diskEncryptionSetParametersSerializer(item["diskEncryptionSet"]),
+        securityProfile: !item["securityProfile"]
+            ? item["securityProfile"]
+            : vmDiskSecurityProfileSerializer(item["securityProfile"]),
+    };
+}
+/** Specifies the storage account type for the managed disk. Managed OS disk storage account type can only be set when you create the scale set. NOTE: UltraSSD_LRS can only be used with data disks. It cannot be used with OS Disk. Standard_LRS uses Standard HDD. StandardSSD_LRS uses Standard SSD. Premium_LRS uses Premium SSD. UltraSSD_LRS uses Ultra disk. Premium_ZRS uses Premium SSD zone redundant storage. StandardSSD_ZRS uses Standard SSD zone redundant storage. For more information regarding disks supported for Windows Virtual Machines, refer to https://docs.microsoft.com/azure/virtual-machines/windows/disks-types and, for Linux Virtual Machines, refer to https://docs.microsoft.com/azure/virtual-machines/linux/disks-types */
+export var KnownStorageAccountTypes;
+(function (KnownStorageAccountTypes) {
+    /** Standard_LRS storage account type */
+    KnownStorageAccountTypes["StandardLRS"] = "Standard_LRS";
+    /** Premium_LRS storage account type */
+    KnownStorageAccountTypes["PremiumLRS"] = "Premium_LRS";
+    /** StandardSSD_LRS storage account type */
+    KnownStorageAccountTypes["StandardSSDLRS"] = "StandardSSD_LRS";
+    /** UltraSSD_LRS storage account type */
+    KnownStorageAccountTypes["UltraSSDLRS"] = "UltraSSD_LRS";
+    /** Premium_ZRS storage account type */
+    KnownStorageAccountTypes["PremiumZRS"] = "Premium_ZRS";
+    /** StandardSSD_ZRS storage account type */
+    KnownStorageAccountTypes["StandardSSDZRS"] = "StandardSSD_ZRS";
+    /** PremiumV2_LRS storage account type */
+    KnownStorageAccountTypes["PremiumV2LRS"] = "PremiumV2_LRS";
+})(KnownStorageAccountTypes || (KnownStorageAccountTypes = {}));
+export function diskEncryptionSetParametersSerializer(item) {
+    return { id: item["id"] };
+}
+export function vmDiskSecurityProfileSerializer(item) {
+    return {
+        securityEncryptionType: item["securityEncryptionType"],
+        diskEncryptionSet: !item["diskEncryptionSet"]
+            ? item["diskEncryptionSet"]
+            : diskEncryptionSetParametersSerializer(item["diskEncryptionSet"]),
+    };
+}
+/** Specifies the EncryptionType of the managed disk. It is set to DiskWithVMGuestState for encryption of the managed disk along with VMGuestState blob, VMGuestStateOnly for encryption of just the VMGuestState blob, and NonPersistedTPM for not persisting firmware state in the VMGuestState blob.. **Note:** It can be set for only Confidential VMs. */
+export var KnownSecurityEncryptionTypes;
+(function (KnownSecurityEncryptionTypes) {
+    /** VMGuestStateOnly encryption */
+    KnownSecurityEncryptionTypes["VMGuestStateOnly"] = "VMGuestStateOnly";
+    /** DiskWithVMGuestState encryption */
+    KnownSecurityEncryptionTypes["DiskWithVMGuestState"] = "DiskWithVMGuestState";
+    /** NonPersistedTPM encryption */
+    KnownSecurityEncryptionTypes["NonPersistedTPM"] = "NonPersistedTPM";
+})(KnownSecurityEncryptionTypes || (KnownSecurityEncryptionTypes = {}));
+/** Specifies the behavior of the managed disk when the VM gets deleted, for example whether the managed disk is deleted or detached. Supported values are: **Delete.** If this value is used, the managed disk is deleted when VM gets deleted. **Detach.** If this value is used, the managed disk is retained after VM gets deleted. Minimum api-version: 2021-03-01. */
+export var KnownDiskDeleteOptionTypes;
+(function (KnownDiskDeleteOptionTypes) {
+    /** Delete the disk upon VM deletion */
+    KnownDiskDeleteOptionTypes["Delete"] = "Delete";
+    /** Detach the disk upon VM deletion */
+    KnownDiskDeleteOptionTypes["Detach"] = "Detach";
+})(KnownDiskDeleteOptionTypes || (KnownDiskDeleteOptionTypes = {}));
+export function dataDiskArraySerializer(result) {
+    return result.map((item) => {
+        return dataDiskSerializer(item);
+    });
+}
+export function dataDiskSerializer(item) {
+    return {
+        lun: item["lun"],
+        name: item["name"],
+        vhd: !item["vhd"] ? item["vhd"] : virtualHardDiskSerializer(item["vhd"]),
+        image: !item["image"] ? item["image"] : virtualHardDiskSerializer(item["image"]),
+        caching: item["caching"],
+        writeAcceleratorEnabled: item["writeAcceleratorEnabled"],
+        createOption: item["createOption"],
+        diskSizeGB: item["diskSizeGB"],
+        managedDisk: !item["managedDisk"]
+            ? item["managedDisk"]
+            : managedDiskParametersSerializer(item["managedDisk"]),
+        sourceResource: !item["sourceResource"]
+            ? item["sourceResource"]
+            : apiEntityReferenceSerializer(item["sourceResource"]),
+        toBeDetached: item["toBeDetached"],
+        detachOption: item["detachOption"],
+        deleteOption: item["deleteOption"],
+    };
+}
+export function apiEntityReferenceSerializer(item) {
+    return { id: item["id"] };
+}
+/** Specifies the detach behavior to be used while detaching a disk or which is already in the process of detachment from the virtual machine. Supported values are: **ForceDetach.** detachOption: **ForceDetach** is applicable only for managed data disks. If a previous detachment attempt of the data disk did not complete due to an unexpected failure from the virtual machine and the disk is still not released then use force-detach as a last resort option to detach the disk forcibly from the VM. All writes might not have been flushed when using this detach behavior. **This feature is still in preview**. To force-detach a data disk update toBeDetached to 'true' along with setting detachOption: 'ForceDetach'. */
+export var KnownDiskDetachOptionTypes;
+(function (KnownDiskDetachOptionTypes) {
+    /** ForceDetach the disk */
+    KnownDiskDetachOptionTypes["ForceDetach"] = "ForceDetach";
+})(KnownDiskDetachOptionTypes || (KnownDiskDetachOptionTypes = {}));
+/** Specifies the disk controller type configured for the VM and VirtualMachineScaleSet. This property is only supported for virtual machines whose operating system disk and VM sku supports Generation 2 (https://docs.microsoft.com/en-us/azure/virtual-machines/generation-2), please check the HyperVGenerations capability returned as part of VM sku capabilities in the response of Microsoft.Compute SKUs api for the region contains V2 (https://docs.microsoft.com/rest/api/compute/resourceskus/list). For more information about Disk Controller Types supported please refer to https://aka.ms/azure-diskcontrollertypes. */
+export var KnownDiskControllerTypes;
+(function (KnownDiskControllerTypes) {
+    /** SCSI disk controller type */
+    KnownDiskControllerTypes["Scsi"] = "SCSI";
+    /** NVMe disk controller type */
+    KnownDiskControllerTypes["NVMe"] = "NVMe";
+})(KnownDiskControllerTypes || (KnownDiskControllerTypes = {}));
+export function additionalCapabilitiesSerializer(item) {
+    return {
+        ultraSSDEnabled: item["ultraSSDEnabled"],
+        hibernationEnabled: item["hibernationEnabled"],
+    };
+}
+export function osProfileSerializer(item) {
+    return {
+        computerName: item["computerName"],
+        adminUsername: item["adminUsername"],
+        adminPassword: item["adminPassword"],
+        customData: item["customData"],
+        windowsConfiguration: !item["windowsConfiguration"]
+            ? item["windowsConfiguration"]
+            : windowsConfigurationSerializer(item["windowsConfiguration"]),
+        linuxConfiguration: !item["linuxConfiguration"]
+            ? item["linuxConfiguration"]
+            : linuxConfigurationSerializer(item["linuxConfiguration"]),
+        secrets: !item["secrets"] ? item["secrets"] : vaultSecretGroupArraySerializer(item["secrets"]),
+        allowExtensionOperations: item["allowExtensionOperations"],
+        requireGuestProvisionSignal: item["requireGuestProvisionSignal"],
+    };
+}
+export function windowsConfigurationSerializer(item) {
+    return {
+        provisionVMAgent: item["provisionVMAgent"],
+        enableAutomaticUpdates: item["enableAutomaticUpdates"],
+        timeZone: item["timeZone"],
+        additionalUnattendContent: !item["additionalUnattendContent"]
+            ? item["additionalUnattendContent"]
+            : additionalUnattendContentArraySerializer(item["additionalUnattendContent"]),
+        patchSettings: !item["patchSettings"]
+            ? item["patchSettings"]
+            : patchSettingsSerializer(item["patchSettings"]),
+        winRM: !item["winRM"] ? item["winRM"] : winRMConfigurationSerializer(item["winRM"]),
+    };
+}
+export function additionalUnattendContentArraySerializer(result) {
+    return result.map((item) => {
+        return additionalUnattendContentSerializer(item);
+    });
+}
+export function additionalUnattendContentSerializer(item) {
+    return {
+        passName: item["passName"],
+        componentName: item["componentName"],
+        settingName: item["settingName"],
+        content: item["content"],
+    };
+}
+/** Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon. */
+export var KnownSettingNames;
+(function (KnownSettingNames) {
+    /** AutoLogon mode */
+    KnownSettingNames["AutoLogon"] = "AutoLogon";
+    /** FirstLogonCommands mode */
+    KnownSettingNames["FirstLogonCommands"] = "FirstLogonCommands";
+})(KnownSettingNames || (KnownSettingNames = {}));
+export function patchSettingsSerializer(item) {
+    return {
+        patchMode: item["patchMode"],
+        enableHotpatching: item["enableHotpatching"],
+        assessmentMode: item["assessmentMode"],
+        automaticByPlatformSettings: !item["automaticByPlatformSettings"]
+            ? item["automaticByPlatformSettings"]
+            : windowsVMGuestPatchAutomaticByPlatformSettingsSerializer(item["automaticByPlatformSettings"]),
+    };
+}
+/** Specifies the mode of VM Guest Patching to IaaS virtual machine or virtual machines associated to virtual machine scale set with OrchestrationMode as Flexible.<br /><br /> Possible values are:<br /><br /> **Manual** - You  control the application of patches to a virtual machine. You do this by applying patches manually inside the VM. In this mode, automatic updates are disabled; the property WindowsConfiguration.enableAutomaticUpdates must be false<br /><br /> **AutomaticByOS** - The virtual machine will automatically be updated by the OS. The property WindowsConfiguration.enableAutomaticUpdates must be true. <br /><br /> **AutomaticByPlatform** - the virtual machine will automatically updated by the platform. The properties provisionVMAgent and WindowsConfiguration.enableAutomaticUpdates must be true */
+export var KnownWindowsVMGuestPatchMode;
+(function (KnownWindowsVMGuestPatchMode) {
+    /** Manual VM guest patch mode */
+    KnownWindowsVMGuestPatchMode["Manual"] = "Manual";
+    /** AutomaticByOS VM guest patch mode */
+    KnownWindowsVMGuestPatchMode["AutomaticByOS"] = "AutomaticByOS";
+    /** AutomaticByPlatform VM guest patch mode */
+    KnownWindowsVMGuestPatchMode["AutomaticByPlatform"] = "AutomaticByPlatform";
+})(KnownWindowsVMGuestPatchMode || (KnownWindowsVMGuestPatchMode = {}));
+/** Specifies the mode of VM Guest patch assessment for the IaaS virtual machine.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - You control the timing of patch assessments on a virtual machine.<br /><br /> **AutomaticByPlatform** - The platform will trigger periodic patch assessments. The property provisionVMAgent must be true. */
+export var KnownWindowsPatchAssessmentMode;
+(function (KnownWindowsPatchAssessmentMode) {
+    /** ImageDefault patch assessment mode */
+    KnownWindowsPatchAssessmentMode["ImageDefault"] = "ImageDefault";
+    /** AutomaticByPlatform patch assessment mode */
+    KnownWindowsPatchAssessmentMode["AutomaticByPlatform"] = "AutomaticByPlatform";
+})(KnownWindowsPatchAssessmentMode || (KnownWindowsPatchAssessmentMode = {}));
+export function windowsVMGuestPatchAutomaticByPlatformSettingsSerializer(item) {
+    return {
+        rebootSetting: item["rebootSetting"],
+        bypassPlatformSafetyChecksOnUserSchedule: item["bypassPlatformSafetyChecksOnUserSchedule"],
+    };
+}
+/** Specifies the reboot setting for all AutomaticByPlatform patch installation operations. */
+export var KnownWindowsVMGuestPatchAutomaticByPlatformRebootSetting;
+(function (KnownWindowsVMGuestPatchAutomaticByPlatformRebootSetting) {
+    /** Reboot setting for Unknown */
+    KnownWindowsVMGuestPatchAutomaticByPlatformRebootSetting["Unknown"] = "Unknown";
+    /** Reboot setting for IfRequired */
+    KnownWindowsVMGuestPatchAutomaticByPlatformRebootSetting["IfRequired"] = "IfRequired";
+    /** Reboot setting for Never */
+    KnownWindowsVMGuestPatchAutomaticByPlatformRebootSetting["Never"] = "Never";
+    /** Reboot setting for Always */
+    KnownWindowsVMGuestPatchAutomaticByPlatformRebootSetting["Always"] = "Always";
+})(KnownWindowsVMGuestPatchAutomaticByPlatformRebootSetting || (KnownWindowsVMGuestPatchAutomaticByPlatformRebootSetting = {}));
+export function winRMConfigurationSerializer(item) {
+    return {
+        listeners: !item["listeners"]
+            ? item["listeners"]
+            : winRMListenerArraySerializer(item["listeners"]),
+    };
+}
+export function winRMListenerArraySerializer(result) {
+    return result.map((item) => {
+        return winRMListenerSerializer(item);
+    });
+}
+export function winRMListenerSerializer(item) {
+    return { protocol: item["protocol"], certificateUrl: item["certificateUrl"] };
+}
+/** Specifies the protocol of WinRM listener. Possible values are: **http,** **https.** */
+export var KnownProtocolTypes;
+(function (KnownProtocolTypes) {
+    /** Http protocol */
+    KnownProtocolTypes["Http"] = "Http";
+    /** Https protocol */
+    KnownProtocolTypes["Https"] = "Https";
+})(KnownProtocolTypes || (KnownProtocolTypes = {}));
+export function linuxConfigurationSerializer(item) {
+    return {
+        disablePasswordAuthentication: item["disablePasswordAuthentication"],
+        ssh: !item["ssh"] ? item["ssh"] : sshConfigurationSerializer(item["ssh"]),
+        provisionVMAgent: item["provisionVMAgent"],
+        patchSettings: !item["patchSettings"]
+            ? item["patchSettings"]
+            : linuxPatchSettingsSerializer(item["patchSettings"]),
+        enableVMAgentPlatformUpdates: item["enableVMAgentPlatformUpdates"],
+    };
+}
+export function sshConfigurationSerializer(item) {
+    return {
+        publicKeys: !item["publicKeys"]
+            ? item["publicKeys"]
+            : sshPublicKeyArraySerializer(item["publicKeys"]),
+    };
+}
+export function sshPublicKeyArraySerializer(result) {
+    return result.map((item) => {
+        return sshPublicKeySerializer(item);
+    });
+}
+export function sshPublicKeySerializer(item) {
+    return { path: item["path"], keyData: item["keyData"] };
+}
+export function linuxPatchSettingsSerializer(item) {
+    return {
+        patchMode: item["patchMode"],
+        assessmentMode: item["assessmentMode"],
+        automaticByPlatformSettings: !item["automaticByPlatformSettings"]
+            ? item["automaticByPlatformSettings"]
+            : linuxVMGuestPatchAutomaticByPlatformSettingsSerializer(item["automaticByPlatformSettings"]),
+    };
+}
+/** Specifies the mode of VM Guest Patching to IaaS virtual machine or virtual machines associated to virtual machine scale set with OrchestrationMode as Flexible.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - The virtual machine's default patching configuration is used. <br /><br /> **AutomaticByPlatform** - The virtual machine will be automatically updated by the platform. The property provisionVMAgent must be true */
+export var KnownLinuxVMGuestPatchMode;
+(function (KnownLinuxVMGuestPatchMode) {
+    /** ImageDefault linux VM guest patch mode */
+    KnownLinuxVMGuestPatchMode["ImageDefault"] = "ImageDefault";
+    /** AutomaticByPlatform linux VM guest patch mode */
+    KnownLinuxVMGuestPatchMode["AutomaticByPlatform"] = "AutomaticByPlatform";
+})(KnownLinuxVMGuestPatchMode || (KnownLinuxVMGuestPatchMode = {}));
+/** Specifies the mode of VM Guest Patch Assessment for the IaaS virtual machine.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - You control the timing of patch assessments on a virtual machine. <br /><br /> **AutomaticByPlatform** - The platform will trigger periodic patch assessments. The property provisionVMAgent must be true. */
+export var KnownLinuxPatchAssessmentMode;
+(function (KnownLinuxPatchAssessmentMode) {
+    /** ImageDefault mode */
+    KnownLinuxPatchAssessmentMode["ImageDefault"] = "ImageDefault";
+    /** AutomaticByPlatform mode */
+    KnownLinuxPatchAssessmentMode["AutomaticByPlatform"] = "AutomaticByPlatform";
+})(KnownLinuxPatchAssessmentMode || (KnownLinuxPatchAssessmentMode = {}));
+export function linuxVMGuestPatchAutomaticByPlatformSettingsSerializer(item) {
+    return {
+        rebootSetting: item["rebootSetting"],
+        bypassPlatformSafetyChecksOnUserSchedule: item["bypassPlatformSafetyChecksOnUserSchedule"],
+    };
+}
+/** Specifies the reboot setting for all AutomaticByPlatform patch installation operations. */
+export var KnownLinuxVMGuestPatchAutomaticByPlatformRebootSetting;
+(function (KnownLinuxVMGuestPatchAutomaticByPlatformRebootSetting) {
+    /** Unknown reboot setting */
+    KnownLinuxVMGuestPatchAutomaticByPlatformRebootSetting["Unknown"] = "Unknown";
+    /** Reboot if required */
+    KnownLinuxVMGuestPatchAutomaticByPlatformRebootSetting["IfRequired"] = "IfRequired";
+    /** Never reboot */
+    KnownLinuxVMGuestPatchAutomaticByPlatformRebootSetting["Never"] = "Never";
+    /** Always reboot */
+    KnownLinuxVMGuestPatchAutomaticByPlatformRebootSetting["Always"] = "Always";
+})(KnownLinuxVMGuestPatchAutomaticByPlatformRebootSetting || (KnownLinuxVMGuestPatchAutomaticByPlatformRebootSetting = {}));
+export function vaultSecretGroupArraySerializer(result) {
+    return result.map((item) => {
+        return vaultSecretGroupSerializer(item);
+    });
+}
+export function vaultSecretGroupSerializer(item) {
+    return {
+        sourceVault: !item["sourceVault"]
+            ? item["sourceVault"]
+            : subResourceSerializer(item["sourceVault"]),
+        vaultCertificates: !item["vaultCertificates"]
+            ? item["vaultCertificates"]
+            : vaultCertificateArraySerializer(item["vaultCertificates"]),
+    };
+}
+export function vaultCertificateArraySerializer(result) {
+    return result.map((item) => {
+        return vaultCertificateSerializer(item);
+    });
+}
+export function vaultCertificateSerializer(item) {
+    return { certificateUrl: item["certificateUrl"], certificateStore: item["certificateStore"] };
+}
+export function networkProfileSerializer(item) {
+    return {
+        networkInterfaces: !item["networkInterfaces"]
+            ? item["networkInterfaces"]
+            : networkInterfaceReferenceArraySerializer(item["networkInterfaces"]),
+        networkApiVersion: item["networkApiVersion"] ?? "2026-04-15-preview",
+        networkInterfaceConfigurations: !item["networkInterfaceConfigurations"]
+            ? item["networkInterfaceConfigurations"]
+            : virtualMachineNetworkInterfaceConfigurationArraySerializer(item["networkInterfaceConfigurations"]),
+    };
+}
+export function networkInterfaceReferenceArraySerializer(result) {
+    return result.map((item) => {
+        return networkInterfaceReferenceSerializer(item);
+    });
+}
+export function networkInterfaceReferenceSerializer(item) {
+    return {
+        id: item["id"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : networkInterfaceReferencePropertiesSerializer(item["properties"]),
+    };
+}
+export function networkInterfaceReferencePropertiesSerializer(item) {
+    return { primary: item["primary"], deleteOption: item["deleteOption"] };
+}
+/** Specify what happens to the network interface when the VM is deleted */
+export var KnownDeleteOptions;
+(function (KnownDeleteOptions) {
+    /** Delete network interface when the VM is deleted */
+    KnownDeleteOptions["Delete"] = "Delete";
+    /** Detach network interface when the VM is deleted */
+    KnownDeleteOptions["Detach"] = "Detach";
+})(KnownDeleteOptions || (KnownDeleteOptions = {}));
+/** Specifies the Microsoft.Network API version used when creating networking resources in the Network Interface Configurations */
+export var KnownNetworkApiVersion;
+(function (KnownNetworkApiVersion) {
+    /** 2020-11-01 version */
+    KnownNetworkApiVersion["NetworkApiVersion20201101"] = "2020-11-01";
+    /** 2022-11-01 version */
+    KnownNetworkApiVersion["NetworkApiVersion20221101"] = "2022-11-01";
+})(KnownNetworkApiVersion || (KnownNetworkApiVersion = {}));
+export function virtualMachineNetworkInterfaceConfigurationArraySerializer(result) {
+    return result.map((item) => {
+        return virtualMachineNetworkInterfaceConfigurationSerializer(item);
+    });
+}
+export function virtualMachineNetworkInterfaceConfigurationSerializer(item) {
+    return {
+        name: item["name"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : virtualMachineNetworkInterfaceConfigurationPropertiesSerializer(item["properties"]),
+        tags: item["tags"],
+    };
+}
+export function virtualMachineNetworkInterfaceConfigurationPropertiesSerializer(item) {
+    return {
+        primary: item["primary"],
+        deleteOption: item["deleteOption"],
+        enableAcceleratedNetworking: item["enableAcceleratedNetworking"],
+        disableTcpStateTracking: item["disableTcpStateTracking"],
+        enableFpga: item["enableFpga"],
+        enableIPForwarding: item["enableIPForwarding"],
+        networkSecurityGroup: !item["networkSecurityGroup"]
+            ? item["networkSecurityGroup"]
+            : subResourceSerializer(item["networkSecurityGroup"]),
+        dnsSettings: !item["dnsSettings"]
+            ? item["dnsSettings"]
+            : virtualMachineNetworkInterfaceDnsSettingsConfigurationSerializer(item["dnsSettings"]),
+        ipConfigurations: virtualMachineNetworkInterfaceIPConfigurationArraySerializer(item["ipConfigurations"]),
+        dscpConfiguration: !item["dscpConfiguration"]
+            ? item["dscpConfiguration"]
+            : subResourceSerializer(item["dscpConfiguration"]),
+        auxiliaryMode: item["auxiliaryMode"],
+        auxiliarySku: item["auxiliarySku"],
+    };
+}
+export function virtualMachineNetworkInterfaceDnsSettingsConfigurationSerializer(item) {
+    return {
+        dnsServers: !item["dnsServers"]
+            ? item["dnsServers"]
+            : item["dnsServers"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function virtualMachineNetworkInterfaceIPConfigurationArraySerializer(result) {
+    return result.map((item) => {
+        return virtualMachineNetworkInterfaceIPConfigurationSerializer(item);
+    });
+}
+export function virtualMachineNetworkInterfaceIPConfigurationSerializer(item) {
+    return {
+        name: item["name"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : virtualMachineNetworkInterfaceIPConfigurationPropertiesSerializer(item["properties"]),
+    };
+}
+export function virtualMachineNetworkInterfaceIPConfigurationPropertiesSerializer(item) {
+    return {
+        subnet: !item["subnet"] ? item["subnet"] : subResourceSerializer(item["subnet"]),
+        primary: item["primary"],
+        publicIPAddressConfiguration: !item["publicIPAddressConfiguration"]
+            ? item["publicIPAddressConfiguration"]
+            : virtualMachinePublicIPAddressConfigurationSerializer(item["publicIPAddressConfiguration"]),
+        privateIPAddressVersion: item["privateIPAddressVersion"],
+        applicationSecurityGroups: !item["applicationSecurityGroups"]
+            ? item["applicationSecurityGroups"]
+            : subResourceArraySerializer(item["applicationSecurityGroups"]),
+        applicationGatewayBackendAddressPools: !item["applicationGatewayBackendAddressPools"]
+            ? item["applicationGatewayBackendAddressPools"]
+            : subResourceArraySerializer(item["applicationGatewayBackendAddressPools"]),
+        loadBalancerBackendAddressPools: !item["loadBalancerBackendAddressPools"]
+            ? item["loadBalancerBackendAddressPools"]
+            : subResourceArraySerializer(item["loadBalancerBackendAddressPools"]),
+    };
+}
+export function virtualMachinePublicIPAddressConfigurationSerializer(item) {
+    return {
+        name: item["name"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : virtualMachinePublicIPAddressConfigurationPropertiesSerializer(item["properties"]),
+        sku: !item["sku"] ? item["sku"] : publicIPAddressSkuSerializer(item["sku"]),
+        tags: item["tags"],
+    };
+}
+export function virtualMachinePublicIPAddressConfigurationPropertiesSerializer(item) {
+    return {
+        idleTimeoutInMinutes: item["idleTimeoutInMinutes"],
+        deleteOption: item["deleteOption"],
+        dnsSettings: !item["dnsSettings"]
+            ? item["dnsSettings"]
+            : virtualMachinePublicIPAddressDnsSettingsConfigurationSerializer(item["dnsSettings"]),
+        ipTags: !item["ipTags"] ? item["ipTags"] : virtualMachineIpTagArraySerializer(item["ipTags"]),
+        publicIPPrefix: !item["publicIPPrefix"]
+            ? item["publicIPPrefix"]
+            : subResourceSerializer(item["publicIPPrefix"]),
+        publicIPAddressVersion: item["publicIPAddressVersion"],
+        publicIPAllocationMethod: item["publicIPAllocationMethod"],
+    };
+}
+export function virtualMachinePublicIPAddressDnsSettingsConfigurationSerializer(item) {
+    return {
+        domainNameLabel: item["domainNameLabel"],
+        domainNameLabelScope: item["domainNameLabelScope"],
+    };
+}
+/** The Domain name label scope.The concatenation of the hashed domain name label that generated according to the policy from domain name label scope and vm index will be the domain name labels of the PublicIPAddress resources that will be created */
+export var KnownDomainNameLabelScopeTypes;
+(function (KnownDomainNameLabelScopeTypes) {
+    /** TenantReuse scope type */
+    KnownDomainNameLabelScopeTypes["TenantReuse"] = "TenantReuse";
+    /** SubscriptionReuse scope type */
+    KnownDomainNameLabelScopeTypes["SubscriptionReuse"] = "SubscriptionReuse";
+    /** ResourceGroupReuse scope type */
+    KnownDomainNameLabelScopeTypes["ResourceGroupReuse"] = "ResourceGroupReuse";
+    /** NoReuse scope type */
+    KnownDomainNameLabelScopeTypes["NoReuse"] = "NoReuse";
+})(KnownDomainNameLabelScopeTypes || (KnownDomainNameLabelScopeTypes = {}));
+export function virtualMachineIpTagArraySerializer(result) {
+    return result.map((item) => {
+        return virtualMachineIpTagSerializer(item);
+    });
+}
+export function virtualMachineIpTagSerializer(item) {
+    return { ipTagType: item["ipTagType"], tag: item["tag"] };
+}
+/** Available from compute Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'. */
+export var KnownIPVersions;
+(function (KnownIPVersions) {
+    /** IPv4 version */
+    KnownIPVersions["IPv4"] = "IPv4";
+    /** IPv6 version */
+    KnownIPVersions["IPv6"] = "IPv6";
+})(KnownIPVersions || (KnownIPVersions = {}));
+/** Specify the public IP allocation type */
+export var KnownPublicIPAllocationMethod;
+(function (KnownPublicIPAllocationMethod) {
+    /** Dynamic IP allocation */
+    KnownPublicIPAllocationMethod["Dynamic"] = "Dynamic";
+    /** Static IP allocation */
+    KnownPublicIPAllocationMethod["Static"] = "Static";
+})(KnownPublicIPAllocationMethod || (KnownPublicIPAllocationMethod = {}));
+export function publicIPAddressSkuSerializer(item) {
+    return { name: item["name"], tier: item["tier"] };
+}
+/** Specify public IP sku name */
+export var KnownPublicIPAddressSkuName;
+(function (KnownPublicIPAddressSkuName) {
+    /** Basic IP sku name */
+    KnownPublicIPAddressSkuName["Basic"] = "Basic";
+    /** Standard IP sku name */
+    KnownPublicIPAddressSkuName["Standard"] = "Standard";
+})(KnownPublicIPAddressSkuName || (KnownPublicIPAddressSkuName = {}));
+/** Specify public IP sku tier */
+export var KnownPublicIPAddressSkuTier;
+(function (KnownPublicIPAddressSkuTier) {
+    /** Regional IP address sku tier */
+    KnownPublicIPAddressSkuTier["Regional"] = "Regional";
+    /** Global IP address sku tier */
+    KnownPublicIPAddressSkuTier["Global"] = "Global";
+})(KnownPublicIPAddressSkuTier || (KnownPublicIPAddressSkuTier = {}));
+export function subResourceArraySerializer(result) {
+    return result.map((item) => {
+        return subResourceSerializer(item);
+    });
+}
+/** Specifies whether the Auxiliary mode is enabled for the Network Interface resource. */
+export var KnownNetworkInterfaceAuxiliaryMode;
+(function (KnownNetworkInterfaceAuxiliaryMode) {
+    /** None mode */
+    KnownNetworkInterfaceAuxiliaryMode["None"] = "None";
+    /** AcceleratedConnections mode */
+    KnownNetworkInterfaceAuxiliaryMode["AcceleratedConnections"] = "AcceleratedConnections";
+    /** Floating mode */
+    KnownNetworkInterfaceAuxiliaryMode["Floating"] = "Floating";
+})(KnownNetworkInterfaceAuxiliaryMode || (KnownNetworkInterfaceAuxiliaryMode = {}));
+/** Specifies whether the Auxiliary sku is enabled for the Network Interface resource. */
+export var KnownNetworkInterfaceAuxiliarySku;
+(function (KnownNetworkInterfaceAuxiliarySku) {
+    /** None: None sku */
+    KnownNetworkInterfaceAuxiliarySku["None"] = "None";
+    /** A1 sku */
+    KnownNetworkInterfaceAuxiliarySku["A1"] = "A1";
+    /** A2 sku */
+    KnownNetworkInterfaceAuxiliarySku["A2"] = "A2";
+    /** A4 sku */
+    KnownNetworkInterfaceAuxiliarySku["A4"] = "A4";
+    /** A8 sku */
+    KnownNetworkInterfaceAuxiliarySku["A8"] = "A8";
+})(KnownNetworkInterfaceAuxiliarySku || (KnownNetworkInterfaceAuxiliarySku = {}));
+export function hardwareProfileSerializer(item) {
+    return {
+        vmSize: item["vmSize"],
+        vmSizeProperties: !item["vmSizeProperties"]
+            ? item["vmSizeProperties"]
+            : vmSizePropertiesSerializer(item["vmSizeProperties"]),
+    };
+}
+export function vmSizePropertiesSerializer(item) {
+    return { vCpusAvailable: item["vCpusAvailable"], vCpusPerCore: item["vCpusPerCore"] };
+}
+export function securityProfileSerializer(item) {
+    return {
+        uefiSettings: !item["uefiSettings"]
+            ? item["uefiSettings"]
+            : uefiSettingsSerializer(item["uefiSettings"]),
+        encryptionAtHost: item["encryptionAtHost"],
+        securityType: item["securityType"],
+        encryptionIdentity: !item["encryptionIdentity"]
+            ? item["encryptionIdentity"]
+            : encryptionIdentitySerializer(item["encryptionIdentity"]),
+        proxyAgentSettings: !item["proxyAgentSettings"]
+            ? item["proxyAgentSettings"]
+            : proxyAgentSettingsSerializer(item["proxyAgentSettings"]),
+    };
+}
+export function uefiSettingsSerializer(item) {
+    return { secureBootEnabled: item["secureBootEnabled"], vTpmEnabled: item["vTpmEnabled"] };
+}
+/** Specifies the SecurityType of the virtual machine. It has to be set to any specified value to enable UefiSettings. The default behavior is: UefiSettings will not be enabled unless this property is set. */
+export var KnownSecurityTypes;
+(function (KnownSecurityTypes) {
+    /** TrustedLaunch security type */
+    KnownSecurityTypes["TrustedLaunch"] = "TrustedLaunch";
+    /** ConfidentialVM security type */
+    KnownSecurityTypes["ConfidentialVM"] = "ConfidentialVM";
+})(KnownSecurityTypes || (KnownSecurityTypes = {}));
+export function encryptionIdentitySerializer(item) {
+    return { userAssignedIdentityResourceId: item["userAssignedIdentityResourceId"] };
+}
+export function proxyAgentSettingsSerializer(item) {
+    return {
+        enabled: item["enabled"],
+        mode: item["mode"],
+        keyIncarnationId: item["keyIncarnationId"],
+        wireServer: !item["wireServer"]
+            ? item["wireServer"]
+            : hostEndpointSettingsSerializer(item["wireServer"]),
+        imds: !item["imds"] ? item["imds"] : hostEndpointSettingsSerializer(item["imds"]),
+        addProxyAgentExtension: item["addProxyAgentExtension"],
+    };
+}
+/** Specifies the mode that ProxyAgent will execute on if the feature is enabled. ProxyAgent will start to audit or monitor but not enforce access control over requests to host endpoints in Audit mode, while in Enforce mode it will enforce access control. The default value is Enforce mode. */
+export var KnownMode;
+(function (KnownMode) {
+    /** Audit mode */
+    KnownMode["Audit"] = "Audit";
+    /** Enforce mode */
+    KnownMode["Enforce"] = "Enforce";
+})(KnownMode || (KnownMode = {}));
+export function hostEndpointSettingsSerializer(item) {
+    return {
+        mode: item["mode"],
+        inVMAccessControlProfileReferenceId: item["inVMAccessControlProfileReferenceId"],
+    };
+}
+/** Specifies the execution mode. In Audit mode, the system acts as if it is enforcing the access control policy, including emitting access denial entries in the logs but it does not actually deny any requests to host endpoints. In Enforce mode, the system will enforce the access control and it is the recommended mode of operation. */
+export var KnownModes;
+(function (KnownModes) {
+    /** Audit mode */
+    KnownModes["Audit"] = "Audit";
+    /** Enforce mode */
+    KnownModes["Enforce"] = "Enforce";
+    /** Disabled mode */
+    KnownModes["Disabled"] = "Disabled";
+})(KnownModes || (KnownModes = {}));
+export function diagnosticsProfileSerializer(item) {
+    return {
+        bootDiagnostics: !item["bootDiagnostics"]
+            ? item["bootDiagnostics"]
+            : bootDiagnosticsSerializer(item["bootDiagnostics"]),
+    };
+}
+export function bootDiagnosticsSerializer(item) {
+    return { enabled: item["enabled"], storageUri: item["storageUri"] };
+}
+export function scheduledEventsProfileSerializer(item) {
+    return {
+        terminateNotificationProfile: !item["terminateNotificationProfile"]
+            ? item["terminateNotificationProfile"]
+            : terminateNotificationProfileSerializer(item["terminateNotificationProfile"]),
+        osImageNotificationProfile: !item["osImageNotificationProfile"]
+            ? item["osImageNotificationProfile"]
+            : osImageNotificationProfileSerializer(item["osImageNotificationProfile"]),
+    };
+}
+export function terminateNotificationProfileSerializer(item) {
+    return { notBeforeTimeout: item["notBeforeTimeout"], enable: item["enable"] };
+}
+export function osImageNotificationProfileSerializer(item) {
+    return { notBeforeTimeout: item["notBeforeTimeout"], enable: item["enable"] };
+}
+export function capacityReservationProfileSerializer(item) {
+    return {
+        capacityReservationGroup: !item["capacityReservationGroup"]
+            ? item["capacityReservationGroup"]
+            : subResourceSerializer(item["capacityReservationGroup"]),
+    };
+}
+export function applicationProfileSerializer(item) {
+    return {
+        galleryApplications: !item["galleryApplications"]
+            ? item["galleryApplications"]
+            : vmGalleryApplicationArraySerializer(item["galleryApplications"]),
+    };
+}
+export function vmGalleryApplicationArraySerializer(result) {
+    return result.map((item) => {
+        return vmGalleryApplicationSerializer(item);
+    });
+}
+export function vmGalleryApplicationSerializer(item) {
+    return {
+        tags: item["tags"],
+        order: item["order"],
+        packageReferenceId: item["packageReferenceId"],
+        configurationReference: item["configurationReference"],
+        treatFailureAsDeploymentFailure: item["treatFailureAsDeploymentFailure"],
+        enableAutomaticUpgrade: item["enableAutomaticUpgrade"],
+    };
+}
+export function bulkActionVMExtensionArraySerializer(result) {
+    return result.map((item) => {
+        return bulkActionVMExtensionSerializer(item);
+    });
+}
+export function bulkActionVMExtensionSerializer(item) {
+    return {
+        name: item["name"],
+        properties: bulkActionVmExtensionPropertiesSerializer(item["properties"]),
+    };
+}
+export function bulkActionVmExtensionPropertiesSerializer(item) {
+    return {
+        forceUpdateTag: item["forceUpdateTag"],
+        publisher: item["publisher"],
+        type: item["type"],
+        typeHandlerVersion: item["typeHandlerVersion"],
+        autoUpgradeMinorVersion: item["autoUpgradeMinorVersion"],
+        enableAutomaticUpgrade: item["enableAutomaticUpgrade"],
+        settings: item["settings"],
+        protectedSettings: item["protectedSettings"],
+        suppressFailures: item["suppressFailures"],
+        protectedSettingsFromKeyVault: !item["protectedSettingsFromKeyVault"]
+            ? item["protectedSettingsFromKeyVault"]
+            : keyVaultSecretReferenceSerializer(item["protectedSettingsFromKeyVault"]),
+        provisionAfterExtensions: !item["provisionAfterExtensions"]
+            ? item["provisionAfterExtensions"]
+            : item["provisionAfterExtensions"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function bulkVMConfigurationArraySerializer(result) {
+    return result.map((item) => {
+        return bulkVMConfigurationSerializer(item);
+    });
+}
+export function flexPropertiesSerializer(item) {
+    return {
+        vmSizeProfiles: vmSizeProfileArraySerializer(item["vmSizeProfiles"]),
+        osType: item["osType"],
+        priorityProfile: priorityProfileSerializer(item["priorityProfile"]),
+        zoneAllocationPolicy: !item["zoneAllocationPolicy"]
+            ? item["zoneAllocationPolicy"]
+            : zoneAllocationPolicySerializer(item["zoneAllocationPolicy"]),
+    };
+}
+export function vmSizeProfileArraySerializer(result) {
+    return result.map((item) => {
+        return vmSizeProfileSerializer(item);
+    });
+}
+export function vmSizeProfileSerializer(item) {
+    return { name: item["name"], rank: item["rank"] };
+}
+/** The supported operating system types for flex VM creation */
+export var KnownOsType;
+(function (KnownOsType) {
+    /** Windows operating system */
+    KnownOsType["Windows"] = "Windows";
+    /** Linux operating system */
+    KnownOsType["Linux"] = "Linux";
+})(KnownOsType || (KnownOsType = {}));
+export function priorityProfileSerializer(item) {
+    return { type: item["type"], allocationStrategy: item["allocationStrategy"] };
+}
+/** The priority type for VM allocation */
+export var KnownPriorityType;
+(function (KnownPriorityType) {
+    /** Regular priority VMs */
+    KnownPriorityType["Regular"] = "Regular";
+    /** Spot priority VMs */
+    KnownPriorityType["Spot"] = "Spot";
+})(KnownPriorityType || (KnownPriorityType = {}));
+/** The allocation strategy for VM size selection */
+export var KnownAllocationStrategy;
+(function (KnownAllocationStrategy) {
+    /** Platform prioritizes VM sizes with the lowest hourly cost */
+    KnownAllocationStrategy["LowestPrice"] = "LowestPrice";
+    /** Customer specifies a rank for each VM size, platform uses VM sizes in rank order */
+    KnownAllocationStrategy["Prioritized"] = "Prioritized";
+    /** Platform prioritizes VM sizes with the highest available capacity first */
+    KnownAllocationStrategy["CapacityOptimized"] = "CapacityOptimized";
+})(KnownAllocationStrategy || (KnownAllocationStrategy = {}));
+export function zoneAllocationPolicySerializer(item) {
+    return {
+        distributionStrategy: item["distributionStrategy"],
+        zonePreferences: !item["zonePreferences"]
+            ? item["zonePreferences"]
+            : zonePreferenceArraySerializer(item["zonePreferences"]),
+    };
+}
+/** The distribution strategy for zone allocation */
+export var KnownDistributionStrategy;
+(function (KnownDistributionStrategy) {
+    /** Platform attempts to place as many VMs as possible in a single zone, falls back to multiple zones if needed */
+    KnownDistributionStrategy["BestEffortSingleZone"] = "BestEffortSingleZone";
+    /** Platform uses customer-provided zone rankings to allocate VMs */
+    KnownDistributionStrategy["Prioritized"] = "Prioritized";
+    /** Platform attempts to evenly distribute VMs across all available zones with best effort */
+    KnownDistributionStrategy["BestEffortBalanced"] = "BestEffortBalanced";
+    /** Platform must evenly distribute VMs across zones, request is rejected if exact balance cannot be achieved */
+    KnownDistributionStrategy["StrictBalanced"] = "StrictBalanced";
+})(KnownDistributionStrategy || (KnownDistributionStrategy = {}));
+export function zonePreferenceArraySerializer(result) {
+    return result.map((item) => {
+        return zonePreferenceSerializer(item);
+    });
+}
+export function zonePreferenceSerializer(item) {
+    return { zone: item["zone"], rank: item["rank"] };
+}
+export function createFlexResourceOperationResponseDeserializer(item) {
+    return {
+        description: item["description"],
+        type: item["type"],
+        location: item["location"],
+        results: !item["results"]
+            ? item["results"]
+            : resourceOperationArrayDeserializer(item["results"]),
+    };
+}
 export function executeCreateRequestSerializer(item) {
     return {
         resourceConfigParameters: resourceProvisionPayloadSerializer(item["resourceConfigParameters"]),
         executionParameters: executionParametersSerializer(item["executionParameters"]),
-        correlationid: item["correlationid"],
+        correlationid: item["correlationId"],
     };
 }
 export function resourceProvisionPayloadSerializer(item) {
     return {
-        baseProfile: item["baseProfile"],
-        resourceOverrides: !item["resourceOverrides"]
-            ? item["resourceOverrides"]
-            : item["resourceOverrides"].map((p) => {
-                return p;
-            }),
+        virtualMachineBaseProfile: !item["virtualMachineBaseProfile"]
+            ? item["virtualMachineBaseProfile"]
+            : bulkVMConfigurationSerializer(item["virtualMachineBaseProfile"]),
+        virtualMachineOverrides: !item["virtualMachineOverrides"]
+            ? item["virtualMachineOverrides"]
+            : bulkVMConfigurationArraySerializer(item["virtualMachineOverrides"]),
         resourceCount: item["resourceCount"],
         resourcePrefix: item["resourcePrefix"],
     };
@@ -323,7 +1449,7 @@ export function executeDeleteRequestSerializer(item) {
     return {
         executionParameters: executionParametersSerializer(item["executionParameters"]),
         resources: resourcesSerializer(item["resources"]),
-        correlationid: item["correlationid"],
+        correlationid: item["correlationId"],
         forceDeletion: item["forceDeletion"],
     };
 }
@@ -419,7 +1545,9 @@ export function scheduledActionSerializer(item) {
 }
 export function scheduledActionDeserializer(item) {
     return {
-        tags: item["tags"],
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
         location: item["location"],
         id: item["id"],
         name: item["name"],
@@ -622,12 +1750,14 @@ export function trackedResourceDeserializer(item) {
         systemData: !item["systemData"]
             ? item["systemData"]
             : systemDataDeserializer(item["systemData"]),
-        tags: item["tags"],
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
         location: item["location"],
     };
 }
-export function resourceSerializer(item) {
-    return item;
+export function resourceSerializer(_item) {
+    return {};
 }
 export function resourceDeserializer(item) {
     return {
@@ -734,17 +1864,15 @@ export function scheduledActionResourceDeserializer(item) {
             : notificationPropertiesArrayDeserializer(item["notificationSettings"]),
     };
 }
-export function resourceAttachRequestSerializer(item) {
-    return {
-        resources: scheduledActionResourceCreateArraySerializer(item["resources"]),
-    };
+export function resourceAttachRequestInputSerializer(item) {
+    return { resources: scheduledActionResourceInputArraySerializer(item["resources"]) };
 }
-export function scheduledActionResourceCreateArraySerializer(result) {
+export function scheduledActionResourceInputArraySerializer(result) {
     return result.map((item) => {
-        return scheduledActionResourceCreateSerializer(item);
+        return scheduledActionResourceInputSerializer(item);
     });
 }
-export function scheduledActionResourceCreateSerializer(item) {
+export function scheduledActionResourceInputSerializer(item) {
     return {
         resourceId: item["resourceId"],
         notificationSettings: !item["notificationSettings"]
@@ -785,10 +1913,8 @@ export function resourceDetachRequestSerializer(item) {
         }),
     };
 }
-export function resourcePatchRequestSerializer(item) {
-    return {
-        resources: scheduledActionResourceCreateArraySerializer(item["resources"]),
-    };
+export function resourcePatchRequestInputSerializer(item) {
+    return { resources: scheduledActionResourceInputArraySerializer(item["resources"]) };
 }
 export function cancelOccurrenceRequestSerializer(item) {
     return {
@@ -884,7 +2010,22 @@ export function scheduledActionResourcesDeserializer(item) {
             : systemDataDeserializer(item["systemData"]),
         properties: !item["properties"]
             ? item["properties"]
-            : scheduledActionPropertiesDeserializer(item["properties"]),
+            : scheduledActionsExtensionPropertiesDeserializer(item["properties"]),
+    };
+}
+export function scheduledActionsExtensionPropertiesDeserializer(item) {
+    return {
+        resourceType: item["resourceType"],
+        actionType: item["actionType"],
+        startTime: item["startTime"],
+        endTime: item["endTime"],
+        schedule: scheduledActionsScheduleDeserializer(item["schedule"]),
+        notificationSettings: notificationPropertiesArrayDeserializer(item["notificationSettings"]),
+        disabled: item["disabled"],
+        provisioningState: item["provisioningState"],
+        resourceNotificationSettings: !item["resourceNotificationSettings"]
+            ? item["resourceNotificationSettings"]
+            : notificationPropertiesArrayDeserializer(item["resourceNotificationSettings"]),
     };
 }
 export function extensionResourceDeserializer(item) {
@@ -981,12 +2122,18 @@ export function occurrenceExtensionPropertiesDeserializer(item) {
 export var KnownVersions;
 (function (KnownVersions) {
     /** 2024-08-15-preview version */
-    KnownVersions["V20240815Preview"] = "2024-08-15-preview";
+    KnownVersions["Versions20240815Preview"] = "2024-08-15-preview";
     /** 2024-10-01 version */
     KnownVersions["V2024-10-01"] = "2024-10-01";
     /** 2025-05-01 version */
     KnownVersions["V20250501"] = "2025-05-01";
     /** 2025-04-15-preview version */
-    KnownVersions["V20250415Preview"] = "2025-04-15-preview";
+    KnownVersions["Versions20250415Preview"] = "2025-04-15-preview";
+    /** 2026-01-01-preview version */
+    KnownVersions["Versions20260101Preview"] = "2026-01-01-preview";
+    /** 2026-03-01-preview version */
+    KnownVersions["Versions20260301Preview"] = "2026-03-01-preview";
+    /** 2026-04-15-preview version */
+    KnownVersions["Versions20260415Preview"] = "2026-04-15-preview";
 })(KnownVersions || (KnownVersions = {}));
 //# sourceMappingURL=models.js.map