@azure/arm-elasticsan 1.2.0-beta.2 → 2.0.0

package/dist/browser/models/models.js

@@ -0,0 +1,985 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export function _operationListResultDeserializer(item) {
+    return {
+        value: operationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function operationArrayDeserializer(result) {
+    return result.map((item) => {
+        return operationDeserializer(item);
+    });
+}
+export function operationDeserializer(item) {
+    return {
+        name: item["name"],
+        isDataAction: item["isDataAction"],
+        display: !item["display"] ? item["display"] : operationDisplayDeserializer(item["display"]),
+        origin: item["origin"],
+        actionType: item["actionType"],
+    };
+}
+export function operationDisplayDeserializer(item) {
+    return {
+        provider: item["provider"],
+        resource: item["resource"],
+        operation: item["operation"],
+        description: item["description"],
+    };
+}
+/** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+export var KnownOrigin;
+(function (KnownOrigin) {
+    /** Indicates the operation is initiated by a user. */
+    KnownOrigin["User"] = "user";
+    /** Indicates the operation is initiated by a system. */
+    KnownOrigin["System"] = "system";
+    /** Indicates the operation is initiated by a user or system. */
+    KnownOrigin["UserSystem"] = "user,system";
+})(KnownOrigin || (KnownOrigin = {}));
+/** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+export var KnownActionType;
+(function (KnownActionType) {
+    /** Actions are for internal-only APIs. */
+    KnownActionType["Internal"] = "Internal";
+})(KnownActionType || (KnownActionType = {}));
+export function errorResponseDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"]),
+    };
+}
+export function errorDetailDeserializer(item) {
+    return {
+        code: item["code"],
+        message: item["message"],
+        target: item["target"],
+        details: !item["details"] ? item["details"] : errorDetailArrayDeserializer(item["details"]),
+        additionalInfo: !item["additionalInfo"]
+            ? item["additionalInfo"]
+            : errorAdditionalInfoArrayDeserializer(item["additionalInfo"]),
+    };
+}
+export function errorDetailArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorDetailDeserializer(item);
+    });
+}
+export function errorAdditionalInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorAdditionalInfoDeserializer(item);
+    });
+}
+export function errorAdditionalInfoDeserializer(item) {
+    return {
+        type: item["type"],
+        info: item["info"],
+    };
+}
+export function elasticSanSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: elasticSanPropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticSanDeserializer(item) {
+    return {
+        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"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: elasticSanPropertiesDeserializer(item["properties"]),
+    };
+}
+export function elasticSanPropertiesSerializer(item) {
+    return {
+        sku: skuSerializer(item["sku"]),
+        availabilityZones: !item["availabilityZones"]
+            ? item["availabilityZones"]
+            : item["availabilityZones"].map((p) => {
+                return p;
+            }),
+        baseSizeTiB: item["baseSizeTiB"],
+        extendedCapacitySizeTiB: item["extendedCapacitySizeTiB"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        autoScaleProperties: !item["autoScaleProperties"]
+            ? item["autoScaleProperties"]
+            : autoScalePropertiesSerializer(item["autoScaleProperties"]),
+    };
+}
+export function elasticSanPropertiesDeserializer(item) {
+    return {
+        sku: skuDeserializer(item["sku"]),
+        availabilityZones: !item["availabilityZones"]
+            ? item["availabilityZones"]
+            : item["availabilityZones"].map((p) => {
+                return p;
+            }),
+        provisioningState: item["provisioningState"],
+        baseSizeTiB: item["baseSizeTiB"],
+        extendedCapacitySizeTiB: item["extendedCapacitySizeTiB"],
+        totalVolumeSizeGiB: item["totalVolumeSizeGiB"],
+        volumeGroupCount: item["volumeGroupCount"],
+        totalIops: item["totalIops"],
+        totalMBps: item["totalMBps"],
+        totalSizeTiB: item["totalSizeTiB"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+        autoScaleProperties: !item["autoScaleProperties"]
+            ? item["autoScaleProperties"]
+            : autoScalePropertiesDeserializer(item["autoScaleProperties"]),
+    };
+}
+export function skuSerializer(item) {
+    return { name: item["name"], tier: item["tier"] };
+}
+export function skuDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+    };
+}
+/** The sku name. */
+export var KnownSkuName;
+(function (KnownSkuName) {
+    /** Premium locally redundant storage */
+    KnownSkuName["PremiumLRS"] = "Premium_LRS";
+    /** Premium zone redundant storage */
+    KnownSkuName["PremiumZRS"] = "Premium_ZRS";
+})(KnownSkuName || (KnownSkuName = {}));
+/** The sku tier. */
+export var KnownSkuTier;
+(function (KnownSkuTier) {
+    /** Premium Tier */
+    KnownSkuTier["Premium"] = "Premium";
+})(KnownSkuTier || (KnownSkuTier = {}));
+/** Provisioning state of the iSCSI Target. */
+export var KnownProvisioningStates;
+(function (KnownProvisioningStates) {
+    /** Invalid */
+    KnownProvisioningStates["Invalid"] = "Invalid";
+    /** Succeeded */
+    KnownProvisioningStates["Succeeded"] = "Succeeded";
+    /** Failed */
+    KnownProvisioningStates["Failed"] = "Failed";
+    /** Canceled */
+    KnownProvisioningStates["Canceled"] = "Canceled";
+    /** Pending */
+    KnownProvisioningStates["Pending"] = "Pending";
+    /** Creating */
+    KnownProvisioningStates["Creating"] = "Creating";
+    /** Updating */
+    KnownProvisioningStates["Updating"] = "Updating";
+    /** Deleting */
+    KnownProvisioningStates["Deleting"] = "Deleting";
+    /** Deleted */
+    KnownProvisioningStates["Deleted"] = "Deleted";
+    /** Restoring */
+    KnownProvisioningStates["Restoring"] = "Restoring";
+})(KnownProvisioningStates || (KnownProvisioningStates = {}));
+export function privateEndpointConnectionArraySerializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionSerializer(item);
+    });
+}
+export function privateEndpointConnectionArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionDeserializer(item);
+    });
+}
+export function privateEndpointConnectionSerializer(item) {
+    return { properties: privateEndpointConnectionPropertiesSerializer(item["properties"]) };
+}
+export function privateEndpointConnectionDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: privateEndpointConnectionPropertiesDeserializer(item["properties"]),
+    };
+}
+export function privateEndpointConnectionPropertiesSerializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointSerializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: privateLinkServiceConnectionStateSerializer(item["privateLinkServiceConnectionState"]),
+        groupIds: !item["groupIds"]
+            ? item["groupIds"]
+            : item["groupIds"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function privateEndpointConnectionPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: privateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+        groupIds: !item["groupIds"]
+            ? item["groupIds"]
+            : item["groupIds"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function privateEndpointSerializer(item) {
+    return item;
+}
+export function privateEndpointDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function privateLinkServiceConnectionStateSerializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+export function privateLinkServiceConnectionStateDeserializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+/** The private endpoint connection status. */
+export var KnownPrivateEndpointServiceConnectionStatus;
+(function (KnownPrivateEndpointServiceConnectionStatus) {
+    /** Pending */
+    KnownPrivateEndpointServiceConnectionStatus["Pending"] = "Pending";
+    /** Approved */
+    KnownPrivateEndpointServiceConnectionStatus["Approved"] = "Approved";
+    /** Failed */
+    KnownPrivateEndpointServiceConnectionStatus["Failed"] = "Failed";
+    /** Rejected */
+    KnownPrivateEndpointServiceConnectionStatus["Rejected"] = "Rejected";
+})(KnownPrivateEndpointServiceConnectionStatus || (KnownPrivateEndpointServiceConnectionStatus = {}));
+/** Allow or disallow public network access to ElasticSan. Value is optional but if passed in, must be 'Enabled' or 'Disabled'. */
+export var KnownPublicNetworkAccess;
+(function (KnownPublicNetworkAccess) {
+    /** Enabled */
+    KnownPublicNetworkAccess["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownPublicNetworkAccess["Disabled"] = "Disabled";
+})(KnownPublicNetworkAccess || (KnownPublicNetworkAccess = {}));
+export function autoScalePropertiesSerializer(item) {
+    return {
+        scaleUpProperties: !item["scaleUpProperties"]
+            ? item["scaleUpProperties"]
+            : scaleUpPropertiesSerializer(item["scaleUpProperties"]),
+    };
+}
+export function autoScalePropertiesDeserializer(item) {
+    return {
+        scaleUpProperties: !item["scaleUpProperties"]
+            ? item["scaleUpProperties"]
+            : scaleUpPropertiesDeserializer(item["scaleUpProperties"]),
+    };
+}
+export function scaleUpPropertiesSerializer(item) {
+    return {
+        unusedSizeTiB: item["unusedSizeTiB"],
+        increaseCapacityUnitByTiB: item["increaseCapacityUnitByTiB"],
+        capacityUnitScaleUpLimitTiB: item["capacityUnitScaleUpLimitTiB"],
+        autoScalePolicyEnforcement: item["autoScalePolicyEnforcement"],
+    };
+}
+export function scaleUpPropertiesDeserializer(item) {
+    return {
+        unusedSizeTiB: item["unusedSizeTiB"],
+        increaseCapacityUnitByTiB: item["increaseCapacityUnitByTiB"],
+        capacityUnitScaleUpLimitTiB: item["capacityUnitScaleUpLimitTiB"],
+        autoScalePolicyEnforcement: item["autoScalePolicyEnforcement"],
+    };
+}
+/** Enable or Disable scale up setting on Elastic San Appliance. */
+export var KnownAutoScalePolicyEnforcement;
+(function (KnownAutoScalePolicyEnforcement) {
+    /** None */
+    KnownAutoScalePolicyEnforcement["None"] = "None";
+    /** Enabled */
+    KnownAutoScalePolicyEnforcement["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownAutoScalePolicyEnforcement["Disabled"] = "Disabled";
+})(KnownAutoScalePolicyEnforcement || (KnownAutoScalePolicyEnforcement = {}));
+export function proxyResourceSerializer(item) {
+    return item;
+}
+export function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function resourceSerializer(item) {
+    return item;
+}
+export function resourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function systemDataDeserializer(item) {
+    return {
+        createdBy: item["createdBy"],
+        createdByType: item["createdByType"],
+        createdAt: !item["createdAt"] ? item["createdAt"] : new Date(item["createdAt"]),
+        lastModifiedBy: item["lastModifiedBy"],
+        lastModifiedByType: item["lastModifiedByType"],
+        lastModifiedAt: !item["lastModifiedAt"]
+            ? item["lastModifiedAt"]
+            : new Date(item["lastModifiedAt"]),
+    };
+}
+/** The kind of entity that created the resource. */
+export var KnownCreatedByType;
+(function (KnownCreatedByType) {
+    /** The entity was created by a user. */
+    KnownCreatedByType["User"] = "User";
+    /** The entity was created by an application. */
+    KnownCreatedByType["Application"] = "Application";
+    /** The entity was created by a managed identity. */
+    KnownCreatedByType["ManagedIdentity"] = "ManagedIdentity";
+    /** The entity was created by a key. */
+    KnownCreatedByType["Key"] = "Key";
+})(KnownCreatedByType || (KnownCreatedByType = {}));
+export function trackedResourceSerializer(item) {
+    return { tags: item["tags"], location: item["location"] };
+}
+export function trackedResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+    };
+}
+export function elasticSanUpdateSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticSanUpdatePropertiesSerializer(item["properties"]),
+        tags: item["tags"],
+    };
+}
+export function elasticSanUpdatePropertiesSerializer(item) {
+    return {
+        baseSizeTiB: item["baseSizeTiB"],
+        extendedCapacitySizeTiB: item["extendedCapacitySizeTiB"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        autoScaleProperties: !item["autoScaleProperties"]
+            ? item["autoScaleProperties"]
+            : autoScalePropertiesSerializer(item["autoScaleProperties"]),
+    };
+}
+export function _elasticSanListDeserializer(item) {
+    return {
+        value: elasticSanArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticSanArraySerializer(result) {
+    return result.map((item) => {
+        return elasticSanSerializer(item);
+    });
+}
+export function elasticSanArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticSanDeserializer(item);
+    });
+}
+export function _privateEndpointConnectionListResultDeserializer(item) {
+    return {
+        value: privateEndpointConnectionArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function volumeSerializer(item) {
+    return { properties: volumePropertiesSerializer(item["properties"]) };
+}
+export function volumeDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: volumePropertiesDeserializer(item["properties"]),
+    };
+}
+export function volumePropertiesSerializer(item) {
+    return {
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : sourceCreationDataSerializer(item["creationData"]),
+        sizeGiB: item["sizeGiB"],
+        managedBy: !item["managedBy"] ? item["managedBy"] : managedByInfoSerializer(item["managedBy"]),
+    };
+}
+export function volumePropertiesDeserializer(item) {
+    return {
+        volumeId: item["volumeId"],
+        creationData: !item["creationData"]
+            ? item["creationData"]
+            : sourceCreationDataDeserializer(item["creationData"]),
+        sizeGiB: item["sizeGiB"],
+        storageTarget: !item["storageTarget"]
+            ? item["storageTarget"]
+            : iscsiTargetInfoDeserializer(item["storageTarget"]),
+        managedBy: !item["managedBy"]
+            ? item["managedBy"]
+            : managedByInfoDeserializer(item["managedBy"]),
+        provisioningState: item["provisioningState"],
+    };
+}
+export function sourceCreationDataSerializer(item) {
+    return { createSource: item["createSource"], sourceId: item["sourceId"] };
+}
+export function sourceCreationDataDeserializer(item) {
+    return {
+        createSource: item["createSource"],
+        sourceId: item["sourceId"],
+    };
+}
+/** This enumerates the possible sources of a volume creation. */
+export var KnownVolumeCreateOption;
+(function (KnownVolumeCreateOption) {
+    /** None */
+    KnownVolumeCreateOption["None"] = "None";
+    /** VolumeSnapshot */
+    KnownVolumeCreateOption["VolumeSnapshot"] = "VolumeSnapshot";
+    /** DiskSnapshot */
+    KnownVolumeCreateOption["DiskSnapshot"] = "DiskSnapshot";
+    /** Disk */
+    KnownVolumeCreateOption["Disk"] = "Disk";
+    /** DiskRestorePoint */
+    KnownVolumeCreateOption["DiskRestorePoint"] = "DiskRestorePoint";
+})(KnownVolumeCreateOption || (KnownVolumeCreateOption = {}));
+export function iscsiTargetInfoDeserializer(item) {
+    return {
+        targetIqn: item["targetIqn"],
+        targetPortalHostname: item["targetPortalHostname"],
+        targetPortalPort: item["targetPortalPort"],
+        provisioningState: item["provisioningState"],
+        status: item["status"],
+    };
+}
+/** Operational status of the resource. */
+export var KnownOperationalStatus;
+(function (KnownOperationalStatus) {
+    /** Invalid */
+    KnownOperationalStatus["Invalid"] = "Invalid";
+    /** Unknown */
+    KnownOperationalStatus["Unknown"] = "Unknown";
+    /** Healthy */
+    KnownOperationalStatus["Healthy"] = "Healthy";
+    /** Unhealthy */
+    KnownOperationalStatus["Unhealthy"] = "Unhealthy";
+    /** Updating */
+    KnownOperationalStatus["Updating"] = "Updating";
+    /** Running */
+    KnownOperationalStatus["Running"] = "Running";
+    /** Stopped */
+    KnownOperationalStatus["Stopped"] = "Stopped";
+    /** Stopped (deallocated) */
+    KnownOperationalStatus["StoppedDeallocated"] = "Stopped (deallocated)";
+})(KnownOperationalStatus || (KnownOperationalStatus = {}));
+export function managedByInfoSerializer(item) {
+    return { resourceId: item["resourceId"] };
+}
+export function managedByInfoDeserializer(item) {
+    return {
+        resourceId: item["resourceId"],
+    };
+}
+export function volumeUpdateSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : volumeUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function volumeUpdatePropertiesSerializer(item) {
+    return {
+        sizeGiB: item["sizeGiB"],
+        managedBy: !item["managedBy"] ? item["managedBy"] : managedByInfoSerializer(item["managedBy"]),
+    };
+}
+export function _volumeListDeserializer(item) {
+    return {
+        value: volumeArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function volumeArraySerializer(result) {
+    return result.map((item) => {
+        return volumeSerializer(item);
+    });
+}
+export function volumeArrayDeserializer(result) {
+    return result.map((item) => {
+        return volumeDeserializer(item);
+    });
+}
+export function volumeNameListSerializer(item) {
+    return {
+        volumeNames: item["volumeNames"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function preValidationResponseDeserializer(item) {
+    return {
+        validationStatus: item["validationStatus"],
+    };
+}
+export function diskSnapshotListSerializer(item) {
+    return {
+        diskSnapshotIds: item["diskSnapshotIds"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function volumeGroupSerializer(item) {
+    return {
+        identity: !item["identity"] ? item["identity"] : identitySerializer(item["identity"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : volumeGroupPropertiesSerializer(item["properties"]),
+    };
+}
+export function volumeGroupDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        identity: !item["identity"] ? item["identity"] : identityDeserializer(item["identity"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : volumeGroupPropertiesDeserializer(item["properties"]),
+    };
+}
+export function identitySerializer(item) {
+    return {
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentityRecordSerializer(item["userAssignedIdentities"]),
+    };
+}
+export function identityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        tenantId: item["tenantId"],
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentityRecordDeserializer(item["userAssignedIdentities"]),
+    };
+}
+/** The identity type. */
+export var KnownIdentityType;
+(function (KnownIdentityType) {
+    /** None */
+    KnownIdentityType["None"] = "None";
+    /** SystemAssigned */
+    KnownIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** UserAssigned */
+    KnownIdentityType["UserAssigned"] = "UserAssigned";
+})(KnownIdentityType || (KnownIdentityType = {}));
+export function userAssignedIdentityRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentitySerializer(item[key]);
+    });
+    return result;
+}
+export function userAssignedIdentityRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentityDeserializer(item[key]);
+    });
+    return result;
+}
+export function userAssignedIdentitySerializer(item) {
+    return item;
+}
+export function userAssignedIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+export function volumeGroupPropertiesSerializer(item) {
+    return {
+        protocolType: item["protocolType"],
+        encryption: item["encryption"],
+        encryptionProperties: !item["encryptionProperties"]
+            ? item["encryptionProperties"]
+            : encryptionPropertiesSerializer(item["encryptionProperties"]),
+        networkAcls: !item["networkAcls"]
+            ? item["networkAcls"]
+            : networkRuleSetSerializer(item["networkAcls"]),
+        enforceDataIntegrityCheckForIscsi: item["enforceDataIntegrityCheckForIscsi"],
+    };
+}
+export function volumeGroupPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        protocolType: item["protocolType"],
+        encryption: item["encryption"],
+        encryptionProperties: !item["encryptionProperties"]
+            ? item["encryptionProperties"]
+            : encryptionPropertiesDeserializer(item["encryptionProperties"]),
+        networkAcls: !item["networkAcls"]
+            ? item["networkAcls"]
+            : networkRuleSetDeserializer(item["networkAcls"]),
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        enforceDataIntegrityCheckForIscsi: item["enforceDataIntegrityCheckForIscsi"],
+    };
+}
+/** Storage Target type. */
+export var KnownStorageTargetType;
+(function (KnownStorageTargetType) {
+    /** Iscsi */
+    KnownStorageTargetType["Iscsi"] = "Iscsi";
+    /** None */
+    KnownStorageTargetType["None"] = "None";
+})(KnownStorageTargetType || (KnownStorageTargetType = {}));
+/** The type of key used to encrypt the data of the disk. */
+export var KnownEncryptionType;
+(function (KnownEncryptionType) {
+    /** Volume is encrypted at rest with Platform managed key. It is the default encryption type. */
+    KnownEncryptionType["EncryptionAtRestWithPlatformKey"] = "EncryptionAtRestWithPlatformKey";
+    /** Volume is encrypted at rest with Customer managed key that can be changed and revoked by a customer. */
+    KnownEncryptionType["EncryptionAtRestWithCustomerManagedKey"] = "EncryptionAtRestWithCustomerManagedKey";
+})(KnownEncryptionType || (KnownEncryptionType = {}));
+export function encryptionPropertiesSerializer(item) {
+    return {
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : keyVaultPropertiesSerializer(item["keyVaultProperties"]),
+        identity: !item["encryptionIdentity"]
+            ? item["encryptionIdentity"]
+            : encryptionIdentitySerializer(item["encryptionIdentity"]),
+    };
+}
+export function encryptionPropertiesDeserializer(item) {
+    return {
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : keyVaultPropertiesDeserializer(item["keyVaultProperties"]),
+        encryptionIdentity: !item["identity"]
+            ? item["identity"]
+            : encryptionIdentityDeserializer(item["identity"]),
+    };
+}
+export function keyVaultPropertiesSerializer(item) {
+    return {
+        keyName: item["keyName"],
+        keyVersion: item["keyVersion"],
+        keyVaultUri: item["keyVaultUri"],
+    };
+}
+export function keyVaultPropertiesDeserializer(item) {
+    return {
+        keyName: item["keyName"],
+        keyVersion: item["keyVersion"],
+        keyVaultUri: item["keyVaultUri"],
+        currentVersionedKeyIdentifier: item["currentVersionedKeyIdentifier"],
+        lastKeyRotationTimestamp: !item["lastKeyRotationTimestamp"]
+            ? item["lastKeyRotationTimestamp"]
+            : new Date(item["lastKeyRotationTimestamp"]),
+        currentVersionedKeyExpirationTimestamp: !item["currentVersionedKeyExpirationTimestamp"]
+            ? item["currentVersionedKeyExpirationTimestamp"]
+            : new Date(item["currentVersionedKeyExpirationTimestamp"]),
+    };
+}
+export function encryptionIdentitySerializer(item) {
+    return { userAssignedIdentity: item["encryptionUserAssignedIdentity"] };
+}
+export function encryptionIdentityDeserializer(item) {
+    return {
+        encryptionUserAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+export function networkRuleSetSerializer(item) {
+    return {
+        virtualNetworkRules: !item["virtualNetworkRules"]
+            ? item["virtualNetworkRules"]
+            : virtualNetworkRuleArraySerializer(item["virtualNetworkRules"]),
+    };
+}
+export function networkRuleSetDeserializer(item) {
+    return {
+        virtualNetworkRules: !item["virtualNetworkRules"]
+            ? item["virtualNetworkRules"]
+            : virtualNetworkRuleArrayDeserializer(item["virtualNetworkRules"]),
+    };
+}
+export function virtualNetworkRuleArraySerializer(result) {
+    return result.map((item) => {
+        return virtualNetworkRuleSerializer(item);
+    });
+}
+export function virtualNetworkRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return virtualNetworkRuleDeserializer(item);
+    });
+}
+export function virtualNetworkRuleSerializer(item) {
+    return { id: item["virtualNetworkResourceId"], action: item["action"] };
+}
+export function virtualNetworkRuleDeserializer(item) {
+    return {
+        virtualNetworkResourceId: item["id"],
+        action: item["action"],
+    };
+}
+/** The action of virtual network rule. */
+export var KnownAction;
+(function (KnownAction) {
+    /** Allow */
+    KnownAction["Allow"] = "Allow";
+})(KnownAction || (KnownAction = {}));
+export function volumeGroupUpdateSerializer(item) {
+    return {
+        identity: !item["identity"] ? item["identity"] : identitySerializer(item["identity"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : volumeGroupUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function volumeGroupUpdatePropertiesSerializer(item) {
+    return {
+        protocolType: item["protocolType"],
+        encryption: item["encryption"],
+        encryptionProperties: !item["encryptionProperties"]
+            ? item["encryptionProperties"]
+            : encryptionPropertiesSerializer(item["encryptionProperties"]),
+        networkAcls: !item["networkAcls"]
+            ? item["networkAcls"]
+            : networkRuleSetSerializer(item["networkAcls"]),
+        enforceDataIntegrityCheckForIscsi: item["enforceDataIntegrityCheckForIscsi"],
+    };
+}
+export function _volumeGroupListDeserializer(item) {
+    return {
+        value: volumeGroupArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function volumeGroupArraySerializer(result) {
+    return result.map((item) => {
+        return volumeGroupSerializer(item);
+    });
+}
+export function volumeGroupArrayDeserializer(result) {
+    return result.map((item) => {
+        return volumeGroupDeserializer(item);
+    });
+}
+export function privateLinkResourceListResultDeserializer(item) {
+    return {
+        value: privateLinkResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function privateLinkResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateLinkResourceDeserializer(item);
+    });
+}
+export function privateLinkResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : privateLinkResourcePropertiesDeserializer(item["properties"]),
+    };
+}
+export function privateLinkResourcePropertiesDeserializer(item) {
+    return {
+        groupId: item["groupId"],
+        requiredMembers: !item["requiredMembers"]
+            ? item["requiredMembers"]
+            : item["requiredMembers"].map((p) => {
+                return p;
+            }),
+        requiredZoneNames: !item["requiredZoneNames"]
+            ? item["requiredZoneNames"]
+            : item["requiredZoneNames"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function snapshotSerializer(item) {
+    return { properties: snapshotPropertiesSerializer(item["properties"]) };
+}
+export function snapshotDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: snapshotPropertiesDeserializer(item["properties"]),
+    };
+}
+export function snapshotPropertiesSerializer(item) {
+    return { creationData: snapshotCreationDataSerializer(item["creationData"]) };
+}
+export function snapshotPropertiesDeserializer(item) {
+    return {
+        creationData: snapshotCreationDataDeserializer(item["creationData"]),
+        provisioningState: item["provisioningState"],
+        sourceVolumeSizeGiB: item["sourceVolumeSizeGiB"],
+        volumeName: item["volumeName"],
+    };
+}
+export function snapshotCreationDataSerializer(item) {
+    return { sourceId: item["sourceId"] };
+}
+export function snapshotCreationDataDeserializer(item) {
+    return {
+        sourceId: item["sourceId"],
+    };
+}
+export function _snapshotListDeserializer(item) {
+    return {
+        value: snapshotArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function snapshotArraySerializer(result) {
+    return result.map((item) => {
+        return snapshotSerializer(item);
+    });
+}
+export function snapshotArrayDeserializer(result) {
+    return result.map((item) => {
+        return snapshotDeserializer(item);
+    });
+}
+export function _skuInformationListDeserializer(item) {
+    return {
+        value: skuInformationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function skuInformationArrayDeserializer(result) {
+    return result.map((item) => {
+        return skuInformationDeserializer(item);
+    });
+}
+export function skuInformationDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        resourceType: item["resourceType"],
+        locations: !item["locations"]
+            ? item["locations"]
+            : item["locations"].map((p) => {
+                return p;
+            }),
+        locationInfo: !item["locationInfo"]
+            ? item["locationInfo"]
+            : skuLocationInfoArrayDeserializer(item["locationInfo"]),
+        capabilities: !item["capabilities"]
+            ? item["capabilities"]
+            : skuCapabilityArrayDeserializer(item["capabilities"]),
+    };
+}
+export function skuLocationInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return skuLocationInfoDeserializer(item);
+    });
+}
+export function skuLocationInfoDeserializer(item) {
+    return {
+        location: item["location"],
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function skuCapabilityArrayDeserializer(result) {
+    return result.map((item) => {
+        return skuCapabilityDeserializer(item);
+    });
+}
+export function skuCapabilityDeserializer(item) {
+    return {
+        name: item["name"],
+        value: item["value"],
+    };
+}
+/** Known values of {@link x-ms-delete-snapshots} that the service accepts. */
+export var KnownXMsDeleteSnapshots;
+(function (KnownXMsDeleteSnapshots) {
+    /** true */
+    KnownXMsDeleteSnapshots["True"] = "true";
+    /** false */
+    KnownXMsDeleteSnapshots["False"] = "false";
+})(KnownXMsDeleteSnapshots || (KnownXMsDeleteSnapshots = {}));
+/** Known values of {@link x-ms-force-delete} that the service accepts. */
+export var KnownXMsForceDelete;
+(function (KnownXMsForceDelete) {
+    /** true */
+    KnownXMsForceDelete["True"] = "true";
+    /** false */
+    KnownXMsForceDelete["False"] = "false";
+})(KnownXMsForceDelete || (KnownXMsForceDelete = {}));
+/** The available API versions. */
+export var KnownVersions;
+(function (KnownVersions) {
+    /** The 2025-09-01 stable API version. */
+    KnownVersions["V20250901"] = "2025-09-01";
+})(KnownVersions || (KnownVersions = {}));
+//# sourceMappingURL=models.js.map