@azure/arm-recoveryservices 6.1.0-alpha.20251022.1 → 7.0.0

package/dist/react-native/models/models.js

@@ -0,0 +1,1314 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { uint8ArrayToString, stringToUint8Array } from "@azure/core-util";
+export function operationResourceDeserializer(item) {
+    return {
+        endTime: !item["endTime"] ? item["endTime"] : new Date(item["endTime"]),
+        error: !item["error"] ? item["error"] : errorDeserializer(item["error"]),
+        id: item["id"],
+        name: item["name"],
+        status: item["status"],
+        startTime: !item["startTime"] ? item["startTime"] : new Date(item["startTime"]),
+    };
+}
+export function errorDeserializer(item) {
+    return {
+        additionalInfo: !item["additionalInfo"]
+            ? item["additionalInfo"]
+            : errorAdditionalInfoArrayDeserializer(item["additionalInfo"]),
+        code: item["code"],
+        details: !item["details"] ? item["details"] : errorArrayDeserializer(item["details"]),
+        message: item["message"],
+        target: item["target"],
+    };
+}
+export function errorAdditionalInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorAdditionalInfoDeserializer(item);
+    });
+}
+export function errorAdditionalInfoDeserializer(item) {
+    return {
+        type: item["type"],
+        info: item["info"],
+    };
+}
+export function errorArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorDeserializer(item);
+    });
+}
+export function cloudErrorDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDeserializer(item["error"]),
+    };
+}
+export function vaultSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : vaultPropertiesSerializer(item["properties"]),
+        identity: !item["identity"] ? item["identity"] : identityDataSerializer(item["identity"]),
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+        etag: item["etag"],
+    };
+}
+export function vaultDeserializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : vaultPropertiesDeserializer(item["properties"]),
+        identity: !item["identity"] ? item["identity"] : identityDataDeserializer(item["identity"]),
+        sku: !item["sku"] ? item["sku"] : skuDeserializer(item["sku"]),
+        etag: item["etag"],
+    };
+}
+export function vaultPropertiesSerializer(item) {
+    return {
+        upgradeDetails: !item["upgradeDetails"]
+            ? item["upgradeDetails"]
+            : upgradeDetailsSerializer(item["upgradeDetails"]),
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : vaultPropertiesEncryptionSerializer(item["encryption"]),
+        moveDetails: !item["moveDetails"]
+            ? item["moveDetails"]
+            : vaultPropertiesMoveDetailsSerializer(item["moveDetails"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+        monitoringSettings: !item["monitoringSettings"]
+            ? item["monitoringSettings"]
+            : monitoringSettingsSerializer(item["monitoringSettings"]),
+        restoreSettings: !item["restoreSettings"]
+            ? item["restoreSettings"]
+            : restoreSettingsSerializer(item["restoreSettings"]),
+        redundancySettings: !item["redundancySettings"]
+            ? item["redundancySettings"]
+            : vaultPropertiesRedundancySettingsSerializer(item["redundancySettings"]),
+        securitySettings: !item["securitySettings"]
+            ? item["securitySettings"]
+            : securitySettingsSerializer(item["securitySettings"]),
+        resourceGuardOperationRequests: !item["resourceGuardOperationRequests"]
+            ? item["resourceGuardOperationRequests"]
+            : item["resourceGuardOperationRequests"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function vaultPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        upgradeDetails: !item["upgradeDetails"]
+            ? item["upgradeDetails"]
+            : upgradeDetailsDeserializer(item["upgradeDetails"]),
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionVaultPropertiesArrayDeserializer(item["privateEndpointConnections"]),
+        privateEndpointStateForBackup: item["privateEndpointStateForBackup"],
+        privateEndpointStateForSiteRecovery: item["privateEndpointStateForSiteRecovery"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : vaultPropertiesEncryptionDeserializer(item["encryption"]),
+        moveDetails: !item["moveDetails"]
+            ? item["moveDetails"]
+            : vaultPropertiesMoveDetailsDeserializer(item["moveDetails"]),
+        moveState: item["moveState"],
+        backupStorageVersion: item["backupStorageVersion"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+        monitoringSettings: !item["monitoringSettings"]
+            ? item["monitoringSettings"]
+            : monitoringSettingsDeserializer(item["monitoringSettings"]),
+        restoreSettings: !item["restoreSettings"]
+            ? item["restoreSettings"]
+            : restoreSettingsDeserializer(item["restoreSettings"]),
+        redundancySettings: !item["redundancySettings"]
+            ? item["redundancySettings"]
+            : vaultPropertiesRedundancySettingsDeserializer(item["redundancySettings"]),
+        securitySettings: !item["securitySettings"]
+            ? item["securitySettings"]
+            : securitySettingsDeserializer(item["securitySettings"]),
+        secureScore: item["secureScore"],
+        bcdrSecurityLevel: item["bcdrSecurityLevel"],
+        resourceGuardOperationRequests: !item["resourceGuardOperationRequests"]
+            ? item["resourceGuardOperationRequests"]
+            : item["resourceGuardOperationRequests"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function upgradeDetailsSerializer(item) {
+    return item;
+}
+export function upgradeDetailsDeserializer(item) {
+    return {
+        operationId: item["operationId"],
+        startTimeUtc: !item["startTimeUtc"] ? item["startTimeUtc"] : new Date(item["startTimeUtc"]),
+        lastUpdatedTimeUtc: !item["lastUpdatedTimeUtc"]
+            ? item["lastUpdatedTimeUtc"]
+            : new Date(item["lastUpdatedTimeUtc"]),
+        endTimeUtc: !item["endTimeUtc"] ? item["endTimeUtc"] : new Date(item["endTimeUtc"]),
+        status: item["status"],
+        message: item["message"],
+        triggerType: item["triggerType"],
+        upgradedResourceId: item["upgradedResourceId"],
+        previousResourceId: item["previousResourceId"],
+    };
+}
+/** Status of the vault upgrade operation. */
+export var KnownVaultUpgradeState;
+(function (KnownVaultUpgradeState) {
+    /** Unknown */
+    KnownVaultUpgradeState["Unknown"] = "Unknown";
+    /** InProgress */
+    KnownVaultUpgradeState["InProgress"] = "InProgress";
+    /** Upgraded */
+    KnownVaultUpgradeState["Upgraded"] = "Upgraded";
+    /** Failed */
+    KnownVaultUpgradeState["Failed"] = "Failed";
+})(KnownVaultUpgradeState || (KnownVaultUpgradeState = {}));
+/** The way the vault upgrade was triggered. */
+export var KnownTriggerType;
+(function (KnownTriggerType) {
+    /** UserTriggered */
+    KnownTriggerType["UserTriggered"] = "UserTriggered";
+    /** ForcedUpgrade */
+    KnownTriggerType["ForcedUpgrade"] = "ForcedUpgrade";
+})(KnownTriggerType || (KnownTriggerType = {}));
+export function privateEndpointConnectionVaultPropertiesArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionVaultPropertiesDeserializer(item);
+    });
+}
+export function privateEndpointConnectionVaultPropertiesDeserializer(item) {
+    return {
+        id: item["id"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : privateEndpointConnectionDeserializer(item["properties"]),
+        name: item["name"],
+        type: item["type"],
+        location: item["location"],
+    };
+}
+export function privateEndpointConnectionDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+        groupIds: !item["groupIds"]
+            ? item["groupIds"]
+            : item["groupIds"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** Gets or sets provisioning state of the private endpoint connection. */
+export var KnownProvisioningState;
+(function (KnownProvisioningState) {
+    /** Succeeded */
+    KnownProvisioningState["Succeeded"] = "Succeeded";
+    /** Deleting */
+    KnownProvisioningState["Deleting"] = "Deleting";
+    /** Failed */
+    KnownProvisioningState["Failed"] = "Failed";
+    /** Pending */
+    KnownProvisioningState["Pending"] = "Pending";
+})(KnownProvisioningState || (KnownProvisioningState = {}));
+export function privateEndpointDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function privateLinkServiceConnectionStateDeserializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+/** Gets or sets the status. */
+export var KnownPrivateEndpointConnectionStatus;
+(function (KnownPrivateEndpointConnectionStatus) {
+    /** Pending */
+    KnownPrivateEndpointConnectionStatus["Pending"] = "Pending";
+    /** Approved */
+    KnownPrivateEndpointConnectionStatus["Approved"] = "Approved";
+    /** Rejected */
+    KnownPrivateEndpointConnectionStatus["Rejected"] = "Rejected";
+    /** Disconnected */
+    KnownPrivateEndpointConnectionStatus["Disconnected"] = "Disconnected";
+})(KnownPrivateEndpointConnectionStatus || (KnownPrivateEndpointConnectionStatus = {}));
+/** Subresource type for vault AzureBackup, AzureBackup_secondary or AzureSiteRecovery */
+export var KnownVaultSubResourceType;
+(function (KnownVaultSubResourceType) {
+    /** AzureBackup */
+    KnownVaultSubResourceType["AzureBackup"] = "AzureBackup";
+    /** AzureBackup_secondary */
+    KnownVaultSubResourceType["AzureBackupSecondary"] = "AzureBackup_secondary";
+    /** AzureSiteRecovery */
+    KnownVaultSubResourceType["AzureSiteRecovery"] = "AzureSiteRecovery";
+})(KnownVaultSubResourceType || (KnownVaultSubResourceType = {}));
+/** Private endpoint state for backup. */
+export var KnownVaultPrivateEndpointState;
+(function (KnownVaultPrivateEndpointState) {
+    /** None */
+    KnownVaultPrivateEndpointState["None"] = "None";
+    /** Enabled */
+    KnownVaultPrivateEndpointState["Enabled"] = "Enabled";
+})(KnownVaultPrivateEndpointState || (KnownVaultPrivateEndpointState = {}));
+export function vaultPropertiesEncryptionSerializer(item) {
+    return {
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : cmkKeyVaultPropertiesSerializer(item["keyVaultProperties"]),
+        kekIdentity: !item["kekIdentity"]
+            ? item["kekIdentity"]
+            : cmkKekIdentitySerializer(item["kekIdentity"]),
+        infrastructureEncryption: item["infrastructureEncryption"],
+    };
+}
+export function vaultPropertiesEncryptionDeserializer(item) {
+    return {
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : cmkKeyVaultPropertiesDeserializer(item["keyVaultProperties"]),
+        kekIdentity: !item["kekIdentity"]
+            ? item["kekIdentity"]
+            : cmkKekIdentityDeserializer(item["kekIdentity"]),
+        infrastructureEncryption: item["infrastructureEncryption"],
+    };
+}
+export function cmkKeyVaultPropertiesSerializer(item) {
+    return { keyUri: item["keyUri"] };
+}
+export function cmkKeyVaultPropertiesDeserializer(item) {
+    return {
+        keyUri: item["keyUri"],
+    };
+}
+export function cmkKekIdentitySerializer(item) {
+    return {
+        useSystemAssignedIdentity: item["useSystemAssignedIdentity"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+export function cmkKekIdentityDeserializer(item) {
+    return {
+        useSystemAssignedIdentity: item["useSystemAssignedIdentity"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+/** Enabling/Disabling the Double Encryption state */
+export var KnownInfrastructureEncryptionState;
+(function (KnownInfrastructureEncryptionState) {
+    /** Enabled */
+    KnownInfrastructureEncryptionState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownInfrastructureEncryptionState["Disabled"] = "Disabled";
+})(KnownInfrastructureEncryptionState || (KnownInfrastructureEncryptionState = {}));
+export function vaultPropertiesMoveDetailsSerializer(item) {
+    return item;
+}
+export function vaultPropertiesMoveDetailsDeserializer(item) {
+    return {
+        operationId: item["operationId"],
+        startTimeUtc: !item["startTimeUtc"] ? item["startTimeUtc"] : new Date(item["startTimeUtc"]),
+        completionTimeUtc: !item["completionTimeUtc"]
+            ? item["completionTimeUtc"]
+            : new Date(item["completionTimeUtc"]),
+        sourceResourceId: item["sourceResourceId"],
+        targetResourceId: item["targetResourceId"],
+    };
+}
+/** The State of the Resource after the move operation */
+export var KnownResourceMoveState;
+(function (KnownResourceMoveState) {
+    /** Unknown */
+    KnownResourceMoveState["Unknown"] = "Unknown";
+    /** InProgress */
+    KnownResourceMoveState["InProgress"] = "InProgress";
+    /** PrepareFailed */
+    KnownResourceMoveState["PrepareFailed"] = "PrepareFailed";
+    /** CommitFailed */
+    KnownResourceMoveState["CommitFailed"] = "CommitFailed";
+    /** PrepareTimedout */
+    KnownResourceMoveState["PrepareTimedout"] = "PrepareTimedout";
+    /** CommitTimedout */
+    KnownResourceMoveState["CommitTimedout"] = "CommitTimedout";
+    /** MoveSucceeded */
+    KnownResourceMoveState["MoveSucceeded"] = "MoveSucceeded";
+    /** Failure */
+    KnownResourceMoveState["Failure"] = "Failure";
+    /** CriticalFailure */
+    KnownResourceMoveState["CriticalFailure"] = "CriticalFailure";
+    /** PartialSuccess */
+    KnownResourceMoveState["PartialSuccess"] = "PartialSuccess";
+})(KnownResourceMoveState || (KnownResourceMoveState = {}));
+/** Backup storage version */
+export var KnownBackupStorageVersion;
+(function (KnownBackupStorageVersion) {
+    /** V1 */
+    KnownBackupStorageVersion["V1"] = "V1";
+    /** V2 */
+    KnownBackupStorageVersion["V2"] = "V2";
+    /** Unassigned */
+    KnownBackupStorageVersion["Unassigned"] = "Unassigned";
+})(KnownBackupStorageVersion || (KnownBackupStorageVersion = {}));
+/** property to enable or disable resource provider inbound network traffic from public clients */
+export var KnownPublicNetworkAccess;
+(function (KnownPublicNetworkAccess) {
+    /** Enabled */
+    KnownPublicNetworkAccess["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownPublicNetworkAccess["Disabled"] = "Disabled";
+})(KnownPublicNetworkAccess || (KnownPublicNetworkAccess = {}));
+export function monitoringSettingsSerializer(item) {
+    return {
+        azureMonitorAlertSettings: !item["azureMonitorAlertSettings"]
+            ? item["azureMonitorAlertSettings"]
+            : azureMonitorAlertSettingsSerializer(item["azureMonitorAlertSettings"]),
+        classicAlertSettings: !item["classicAlertSettings"]
+            ? item["classicAlertSettings"]
+            : classicAlertSettingsSerializer(item["classicAlertSettings"]),
+    };
+}
+export function monitoringSettingsDeserializer(item) {
+    return {
+        azureMonitorAlertSettings: !item["azureMonitorAlertSettings"]
+            ? item["azureMonitorAlertSettings"]
+            : azureMonitorAlertSettingsDeserializer(item["azureMonitorAlertSettings"]),
+        classicAlertSettings: !item["classicAlertSettings"]
+            ? item["classicAlertSettings"]
+            : classicAlertSettingsDeserializer(item["classicAlertSettings"]),
+    };
+}
+export function azureMonitorAlertSettingsSerializer(item) {
+    return {
+        alertsForAllJobFailures: item["alertsForAllJobFailures"],
+        alertsForAllReplicationIssues: item["alertsForAllReplicationIssues"],
+        alertsForAllFailoverIssues: item["alertsForAllFailoverIssues"],
+    };
+}
+export function azureMonitorAlertSettingsDeserializer(item) {
+    return {
+        alertsForAllJobFailures: item["alertsForAllJobFailures"],
+        alertsForAllReplicationIssues: item["alertsForAllReplicationIssues"],
+        alertsForAllFailoverIssues: item["alertsForAllFailoverIssues"],
+    };
+}
+/** Known values of {@link AlertsState} that the service accepts. */
+export var KnownAlertsState;
+(function (KnownAlertsState) {
+    /** Enabled */
+    KnownAlertsState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownAlertsState["Disabled"] = "Disabled";
+})(KnownAlertsState || (KnownAlertsState = {}));
+export function classicAlertSettingsSerializer(item) {
+    return {
+        alertsForCriticalOperations: item["alertsForCriticalOperations"],
+        emailNotificationsForSiteRecovery: item["emailNotificationsForSiteRecovery"],
+    };
+}
+export function classicAlertSettingsDeserializer(item) {
+    return {
+        alertsForCriticalOperations: item["alertsForCriticalOperations"],
+        emailNotificationsForSiteRecovery: item["emailNotificationsForSiteRecovery"],
+    };
+}
+export function restoreSettingsSerializer(item) {
+    return {
+        crossSubscriptionRestoreSettings: !item["crossSubscriptionRestoreSettings"]
+            ? item["crossSubscriptionRestoreSettings"]
+            : crossSubscriptionRestoreSettingsSerializer(item["crossSubscriptionRestoreSettings"]),
+    };
+}
+export function restoreSettingsDeserializer(item) {
+    return {
+        crossSubscriptionRestoreSettings: !item["crossSubscriptionRestoreSettings"]
+            ? item["crossSubscriptionRestoreSettings"]
+            : crossSubscriptionRestoreSettingsDeserializer(item["crossSubscriptionRestoreSettings"]),
+    };
+}
+export function crossSubscriptionRestoreSettingsSerializer(item) {
+    return {
+        crossSubscriptionRestoreState: item["crossSubscriptionRestoreState"],
+    };
+}
+export function crossSubscriptionRestoreSettingsDeserializer(item) {
+    return {
+        crossSubscriptionRestoreState: item["crossSubscriptionRestoreState"],
+    };
+}
+/** Known values of {@link CrossSubscriptionRestoreState} that the service accepts. */
+export var KnownCrossSubscriptionRestoreState;
+(function (KnownCrossSubscriptionRestoreState) {
+    /** Enabled */
+    KnownCrossSubscriptionRestoreState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownCrossSubscriptionRestoreState["Disabled"] = "Disabled";
+    /** PermanentlyDisabled */
+    KnownCrossSubscriptionRestoreState["PermanentlyDisabled"] = "PermanentlyDisabled";
+})(KnownCrossSubscriptionRestoreState || (KnownCrossSubscriptionRestoreState = {}));
+export function vaultPropertiesRedundancySettingsSerializer(item) {
+    return {
+        standardTierStorageRedundancy: item["standardTierStorageRedundancy"],
+        crossRegionRestore: item["crossRegionRestore"],
+    };
+}
+export function vaultPropertiesRedundancySettingsDeserializer(item) {
+    return {
+        standardTierStorageRedundancy: item["standardTierStorageRedundancy"],
+        crossRegionRestore: item["crossRegionRestore"],
+    };
+}
+/** The storage redundancy setting of a vault */
+export var KnownStandardTierStorageRedundancy;
+(function (KnownStandardTierStorageRedundancy) {
+    /** Invalid */
+    KnownStandardTierStorageRedundancy["Invalid"] = "Invalid";
+    /** LocallyRedundant */
+    KnownStandardTierStorageRedundancy["LocallyRedundant"] = "LocallyRedundant";
+    /** GeoRedundant */
+    KnownStandardTierStorageRedundancy["GeoRedundant"] = "GeoRedundant";
+    /** ZoneRedundant */
+    KnownStandardTierStorageRedundancy["ZoneRedundant"] = "ZoneRedundant";
+})(KnownStandardTierStorageRedundancy || (KnownStandardTierStorageRedundancy = {}));
+/** Flag to show if Cross Region Restore is enabled on the Vault or not */
+export var KnownCrossRegionRestore;
+(function (KnownCrossRegionRestore) {
+    /** Enabled */
+    KnownCrossRegionRestore["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownCrossRegionRestore["Disabled"] = "Disabled";
+})(KnownCrossRegionRestore || (KnownCrossRegionRestore = {}));
+export function securitySettingsSerializer(item) {
+    return {
+        immutabilitySettings: !item["immutabilitySettings"]
+            ? item["immutabilitySettings"]
+            : immutabilitySettingsSerializer(item["immutabilitySettings"]),
+        softDeleteSettings: !item["softDeleteSettings"]
+            ? item["softDeleteSettings"]
+            : softDeleteSettingsSerializer(item["softDeleteSettings"]),
+        sourceScanConfiguration: !item["sourceScanConfiguration"]
+            ? item["sourceScanConfiguration"]
+            : sourceScanConfigurationSerializer(item["sourceScanConfiguration"]),
+    };
+}
+export function securitySettingsDeserializer(item) {
+    return {
+        immutabilitySettings: !item["immutabilitySettings"]
+            ? item["immutabilitySettings"]
+            : immutabilitySettingsDeserializer(item["immutabilitySettings"]),
+        softDeleteSettings: !item["softDeleteSettings"]
+            ? item["softDeleteSettings"]
+            : softDeleteSettingsDeserializer(item["softDeleteSettings"]),
+        multiUserAuthorization: item["multiUserAuthorization"],
+        sourceScanConfiguration: !item["sourceScanConfiguration"]
+            ? item["sourceScanConfiguration"]
+            : sourceScanConfigurationDeserializer(item["sourceScanConfiguration"]),
+    };
+}
+export function immutabilitySettingsSerializer(item) {
+    return { state: item["state"] };
+}
+export function immutabilitySettingsDeserializer(item) {
+    return {
+        state: item["state"],
+    };
+}
+/** Known values of {@link ImmutabilityState} that the service accepts. */
+export var KnownImmutabilityState;
+(function (KnownImmutabilityState) {
+    /** Disabled */
+    KnownImmutabilityState["Disabled"] = "Disabled";
+    /** Unlocked */
+    KnownImmutabilityState["Unlocked"] = "Unlocked";
+    /** Locked */
+    KnownImmutabilityState["Locked"] = "Locked";
+})(KnownImmutabilityState || (KnownImmutabilityState = {}));
+export function softDeleteSettingsSerializer(item) {
+    return {
+        softDeleteState: item["softDeleteState"],
+        softDeleteRetentionPeriodInDays: item["softDeleteRetentionPeriodInDays"],
+        enhancedSecurityState: item["enhancedSecurityState"],
+    };
+}
+export function softDeleteSettingsDeserializer(item) {
+    return {
+        softDeleteState: item["softDeleteState"],
+        softDeleteRetentionPeriodInDays: item["softDeleteRetentionPeriodInDays"],
+        enhancedSecurityState: item["enhancedSecurityState"],
+    };
+}
+/** Known values of {@link SoftDeleteState} that the service accepts. */
+export var KnownSoftDeleteState;
+(function (KnownSoftDeleteState) {
+    /** Invalid */
+    KnownSoftDeleteState["Invalid"] = "Invalid";
+    /** Enabled */
+    KnownSoftDeleteState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownSoftDeleteState["Disabled"] = "Disabled";
+    /** AlwaysON */
+    KnownSoftDeleteState["AlwaysON"] = "AlwaysON";
+})(KnownSoftDeleteState || (KnownSoftDeleteState = {}));
+/** Known values of {@link EnhancedSecurityState} that the service accepts. */
+export var KnownEnhancedSecurityState;
+(function (KnownEnhancedSecurityState) {
+    /** Invalid */
+    KnownEnhancedSecurityState["Invalid"] = "Invalid";
+    /** Enabled */
+    KnownEnhancedSecurityState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownEnhancedSecurityState["Disabled"] = "Disabled";
+    /** AlwaysON */
+    KnownEnhancedSecurityState["AlwaysON"] = "AlwaysON";
+})(KnownEnhancedSecurityState || (KnownEnhancedSecurityState = {}));
+/** MUA Settings of vault */
+export var KnownMultiUserAuthorization;
+(function (KnownMultiUserAuthorization) {
+    /** Invalid */
+    KnownMultiUserAuthorization["Invalid"] = "Invalid";
+    /** Enabled */
+    KnownMultiUserAuthorization["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownMultiUserAuthorization["Disabled"] = "Disabled";
+})(KnownMultiUserAuthorization || (KnownMultiUserAuthorization = {}));
+export function sourceScanConfigurationSerializer(item) {
+    return {
+        state: item["state"],
+        sourceScanIdentity: !item["sourceScanIdentity"]
+            ? item["sourceScanIdentity"]
+            : associatedIdentitySerializer(item["sourceScanIdentity"]),
+    };
+}
+export function sourceScanConfigurationDeserializer(item) {
+    return {
+        state: item["state"],
+        sourceScanIdentity: !item["sourceScanIdentity"]
+            ? item["sourceScanIdentity"]
+            : associatedIdentityDeserializer(item["sourceScanIdentity"]),
+    };
+}
+/** Known values of {@link State} that the service accepts. */
+export var KnownState;
+(function (KnownState) {
+    /** Invalid */
+    KnownState["Invalid"] = "Invalid";
+    /** Enabled */
+    KnownState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownState["Disabled"] = "Disabled";
+})(KnownState || (KnownState = {}));
+export function associatedIdentitySerializer(item) {
+    return {
+        operationIdentityType: item["operationIdentityType"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+export function associatedIdentityDeserializer(item) {
+    return {
+        operationIdentityType: item["operationIdentityType"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+/** Identity type that should be used for an operation. */
+export var KnownIdentityType;
+(function (KnownIdentityType) {
+    /** SystemAssigned */
+    KnownIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** UserAssigned */
+    KnownIdentityType["UserAssigned"] = "UserAssigned";
+})(KnownIdentityType || (KnownIdentityType = {}));
+/** Secure Score of Recovery Services Vault */
+export var KnownSecureScoreLevel;
+(function (KnownSecureScoreLevel) {
+    /** None */
+    KnownSecureScoreLevel["None"] = "None";
+    /** Minimum */
+    KnownSecureScoreLevel["Minimum"] = "Minimum";
+    /** Adequate */
+    KnownSecureScoreLevel["Adequate"] = "Adequate";
+    /** Maximum */
+    KnownSecureScoreLevel["Maximum"] = "Maximum";
+})(KnownSecureScoreLevel || (KnownSecureScoreLevel = {}));
+/** Security levels of Recovery Services Vault for business continuity and disaster recovery */
+export var KnownBcdrSecurityLevel;
+(function (KnownBcdrSecurityLevel) {
+    /** Poor */
+    KnownBcdrSecurityLevel["Poor"] = "Poor";
+    /** Fair */
+    KnownBcdrSecurityLevel["Fair"] = "Fair";
+    /** Good */
+    KnownBcdrSecurityLevel["Good"] = "Good";
+    /** Excellent */
+    KnownBcdrSecurityLevel["Excellent"] = "Excellent";
+})(KnownBcdrSecurityLevel || (KnownBcdrSecurityLevel = {}));
+export function identityDataSerializer(item) {
+    return {
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userIdentityRecordSerializer(item["userAssignedIdentities"]),
+    };
+}
+export function identityDataDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        tenantId: item["tenantId"],
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userIdentityRecordDeserializer(item["userAssignedIdentities"]),
+    };
+}
+/** The type of managed identity used. The type 'SystemAssigned, UserAssigned' includes both an implicitly created identity and a set of user-assigned identities. The type 'None' will remove any identities. */
+export var KnownResourceIdentityType;
+(function (KnownResourceIdentityType) {
+    /** SystemAssigned */
+    KnownResourceIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** None */
+    KnownResourceIdentityType["None"] = "None";
+    /** UserAssigned */
+    KnownResourceIdentityType["UserAssigned"] = "UserAssigned";
+    /** SystemAssigned, UserAssigned */
+    KnownResourceIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned, UserAssigned";
+})(KnownResourceIdentityType || (KnownResourceIdentityType = {}));
+export function userIdentityRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userIdentitySerializer(item[key]);
+    });
+    return result;
+}
+export function userIdentityRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userIdentityDeserializer(item[key]);
+    });
+    return result;
+}
+export function userIdentitySerializer(item) {
+    return item;
+}
+export function userIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+export function skuSerializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        family: item["family"],
+        size: item["size"],
+        capacity: item["capacity"],
+    };
+}
+export function skuDeserializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        family: item["family"],
+        size: item["size"],
+        capacity: item["capacity"],
+    };
+}
+/** Name of SKU is RS0 (Recovery Services 0th version) and the tier is standard tier. They do not have affect on backend storage redundancy or any other vault settings. To manage storage redundancy, use the backupstorageconfig */
+export var KnownSkuName;
+(function (KnownSkuName) {
+    /** Standard */
+    KnownSkuName["Standard"] = "Standard";
+    /** RS0 */
+    KnownSkuName["RS0"] = "RS0";
+})(KnownSkuName || (KnownSkuName = {}));
+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"],
+        location: item["location"],
+    };
+}
+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 _clientDiscoveryResponseDeserializer(item) {
+    return {
+        value: clientDiscoveryValueForSingleApiArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function clientDiscoveryValueForSingleApiArrayDeserializer(result) {
+    return result.map((item) => {
+        return clientDiscoveryValueForSingleApiDeserializer(item);
+    });
+}
+export function clientDiscoveryValueForSingleApiDeserializer(item) {
+    return {
+        name: item["name"],
+        display: !item["display"]
+            ? item["display"]
+            : clientDiscoveryDisplayDeserializer(item["display"]),
+        origin: item["origin"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : clientDiscoveryForPropertiesDeserializer(item["properties"]),
+    };
+}
+export function clientDiscoveryDisplayDeserializer(item) {
+    return {
+        provider: item["provider"],
+        resource: item["resource"],
+        operation: item["operation"],
+        description: item["description"],
+    };
+}
+export function clientDiscoveryForPropertiesDeserializer(item) {
+    return {
+        serviceSpecification: !item["serviceSpecification"]
+            ? item["serviceSpecification"]
+            : clientDiscoveryForServiceSpecificationDeserializer(item["serviceSpecification"]),
+    };
+}
+export function clientDiscoveryForServiceSpecificationDeserializer(item) {
+    return {
+        logSpecifications: !item["logSpecifications"]
+            ? item["logSpecifications"]
+            : clientDiscoveryForLogSpecificationArrayDeserializer(item["logSpecifications"]),
+    };
+}
+export function clientDiscoveryForLogSpecificationArrayDeserializer(result) {
+    return result.map((item) => {
+        return clientDiscoveryForLogSpecificationDeserializer(item);
+    });
+}
+export function clientDiscoveryForLogSpecificationDeserializer(item) {
+    return {
+        name: item["name"],
+        displayName: item["displayName"],
+        blobDuration: item["blobDuration"],
+    };
+}
+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 patchVaultSerializer(item) {
+    return {
+        location: item["location"],
+        tags: item["tags"],
+        etag: item["etag"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : vaultPropertiesSerializer(item["properties"]),
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+        identity: !item["identity"] ? item["identity"] : identityDataSerializer(item["identity"]),
+    };
+}
+export function patchTrackedResourceSerializer(item) {
+    return { location: item["location"], tags: item["tags"], etag: item["etag"] };
+}
+export function errorResponseDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"]),
+    };
+}
+export function _vaultListDeserializer(item) {
+    return {
+        value: vaultArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function vaultArraySerializer(result) {
+    return result.map((item) => {
+        return vaultSerializer(item);
+    });
+}
+export function vaultArrayDeserializer(result) {
+    return result.map((item) => {
+        return vaultDeserializer(item);
+    });
+}
+export function _deletedVaultListDeserializer(item) {
+    return {
+        value: deletedVaultArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function deletedVaultArrayDeserializer(result) {
+    return result.map((item) => {
+        return deletedVaultDeserializer(item);
+    });
+}
+export function deletedVaultDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : deletedVaultPropertiesDeserializer(item["properties"]),
+    };
+}
+export function deletedVaultPropertiesDeserializer(item) {
+    return {
+        vaultId: item["vaultId"],
+        vaultDeletionTime: !item["vaultDeletionTime"]
+            ? item["vaultDeletionTime"]
+            : new Date(item["vaultDeletionTime"]),
+        purgeAt: !item["purgeAt"] ? item["purgeAt"] : new Date(item["purgeAt"]),
+    };
+}
+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 deletedVaultUndeleteInputSerializer(item) {
+    return {
+        properties: deletedVaultUndeleteInputPropertiesSerializer(item["properties"]),
+    };
+}
+export function deletedVaultUndeleteInputPropertiesSerializer(item) {
+    return { recoveryResourceGroupId: item["recoveryResourceGroupId"] };
+}
+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 _privateLinkResourcesDeserializer(item) {
+    return {
+        value: privateLinkResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function privateLinkResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateLinkResourceDeserializer(item);
+    });
+}
+export function certificateRequestSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : rawCertificateDataSerializer(item["properties"]),
+    };
+}
+export function rawCertificateDataSerializer(item) {
+    return {
+        authType: item["authType"],
+        certificate: !item["certificate"]
+            ? item["certificate"]
+            : uint8ArrayToString(item["certificate"], "base64"),
+    };
+}
+/** Specifies the authentication type. */
+export var KnownAuthType;
+(function (KnownAuthType) {
+    /** Invalid */
+    KnownAuthType["Invalid"] = "Invalid";
+    /** ACS */
+    KnownAuthType["ACS"] = "ACS";
+    /** AAD */
+    KnownAuthType["AAD"] = "AAD";
+    /** AccessControlService */
+    KnownAuthType["AccessControlService"] = "AccessControlService";
+    /** AzureActiveDirectory */
+    KnownAuthType["AzureActiveDirectory"] = "AzureActiveDirectory";
+})(KnownAuthType || (KnownAuthType = {}));
+export function vaultCertificateResponseDeserializer(item) {
+    return {
+        name: item["name"],
+        type: item["type"],
+        id: item["id"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : resourceCertificateDetailsUnionDeserializer(item["properties"]),
+    };
+}
+export function resourceCertificateDetailsDeserializer(item) {
+    return {
+        authType: item["authType"],
+        certificate: !item["certificate"]
+            ? item["certificate"]
+            : typeof item["certificate"] === "string"
+                ? stringToUint8Array(item["certificate"], "base64")
+                : item["certificate"],
+        friendlyName: item["friendlyName"],
+        issuer: item["issuer"],
+        resourceId: item["resourceId"],
+        subject: item["subject"],
+        thumbprint: item["thumbprint"],
+        validFrom: !item["validFrom"] ? item["validFrom"] : new Date(item["validFrom"]),
+        validTo: !item["validTo"] ? item["validTo"] : new Date(item["validTo"]),
+    };
+}
+export function resourceCertificateDetailsUnionDeserializer(item) {
+    switch (item.authType) {
+        case "AzureActiveDirectory":
+            return resourceCertificateAndAadDetailsDeserializer(item);
+        case "AccessControlService":
+            return resourceCertificateAndAcsDetailsDeserializer(item);
+        default:
+            return resourceCertificateDetailsDeserializer(item);
+    }
+}
+export function resourceCertificateAndAadDetailsDeserializer(item) {
+    return {
+        authType: item["authType"],
+        certificate: !item["certificate"]
+            ? item["certificate"]
+            : typeof item["certificate"] === "string"
+                ? stringToUint8Array(item["certificate"], "base64")
+                : item["certificate"],
+        friendlyName: item["friendlyName"],
+        issuer: item["issuer"],
+        resourceId: item["resourceId"],
+        subject: item["subject"],
+        thumbprint: item["thumbprint"],
+        validFrom: !item["validFrom"] ? item["validFrom"] : new Date(item["validFrom"]),
+        validTo: !item["validTo"] ? item["validTo"] : new Date(item["validTo"]),
+        aadAuthority: item["aadAuthority"],
+        aadTenantId: item["aadTenantId"],
+        servicePrincipalClientId: item["servicePrincipalClientId"],
+        servicePrincipalObjectId: item["servicePrincipalObjectId"],
+        azureManagementEndpointAudience: item["azureManagementEndpointAudience"],
+        serviceResourceId: item["serviceResourceId"],
+        aadAudience: item["aadAudience"],
+    };
+}
+export function resourceCertificateAndAcsDetailsDeserializer(item) {
+    return {
+        authType: item["authType"],
+        certificate: !item["certificate"]
+            ? item["certificate"]
+            : typeof item["certificate"] === "string"
+                ? stringToUint8Array(item["certificate"], "base64")
+                : item["certificate"],
+        friendlyName: item["friendlyName"],
+        issuer: item["issuer"],
+        resourceId: item["resourceId"],
+        subject: item["subject"],
+        thumbprint: item["thumbprint"],
+        validFrom: !item["validFrom"] ? item["validFrom"] : new Date(item["validFrom"]),
+        validTo: !item["validTo"] ? item["validTo"] : new Date(item["validTo"]),
+        globalAcsNamespace: item["globalAcsNamespace"],
+        globalAcsHostName: item["globalAcsHostName"],
+        globalAcsRPRealm: item["globalAcsRPRealm"],
+    };
+}
+export function _replicationUsageListDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : replicationUsageArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function replicationUsageArrayDeserializer(result) {
+    return result.map((item) => {
+        return replicationUsageDeserializer(item);
+    });
+}
+export function replicationUsageDeserializer(item) {
+    return {
+        monitoringSummary: !item["monitoringSummary"]
+            ? item["monitoringSummary"]
+            : monitoringSummaryDeserializer(item["monitoringSummary"]),
+        jobsSummary: !item["jobsSummary"]
+            ? item["jobsSummary"]
+            : jobsSummaryDeserializer(item["jobsSummary"]),
+        protectedItemCount: item["protectedItemCount"],
+        recoveryPlanCount: item["recoveryPlanCount"],
+        registeredServersCount: item["registeredServersCount"],
+        recoveryServicesProviderAuthType: item["recoveryServicesProviderAuthType"],
+    };
+}
+export function monitoringSummaryDeserializer(item) {
+    return {
+        unHealthyVmCount: item["unHealthyVmCount"],
+        unHealthyProviderCount: item["unHealthyProviderCount"],
+        eventsCount: item["eventsCount"],
+        deprecatedProviderCount: item["deprecatedProviderCount"],
+        supportedProviderCount: item["supportedProviderCount"],
+        unsupportedProviderCount: item["unsupportedProviderCount"],
+    };
+}
+export function jobsSummaryDeserializer(item) {
+    return {
+        failedJobs: item["failedJobs"],
+        suspendedJobs: item["suspendedJobs"],
+        inProgressJobs: item["inProgressJobs"],
+    };
+}
+export function _vaultUsageListDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : vaultUsageArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function vaultUsageArrayDeserializer(result) {
+    return result.map((item) => {
+        return vaultUsageDeserializer(item);
+    });
+}
+export function vaultUsageDeserializer(item) {
+    return {
+        unit: item["unit"],
+        quotaPeriod: item["quotaPeriod"],
+        nextResetTime: !item["nextResetTime"] ? item["nextResetTime"] : new Date(item["nextResetTime"]),
+        currentValue: item["currentValue"],
+        limit: item["limit"],
+        name: !item["name"] ? item["name"] : nameInfoDeserializer(item["name"]),
+    };
+}
+/** Unit of the usage. */
+export var KnownUsagesUnit;
+(function (KnownUsagesUnit) {
+    /** Count */
+    KnownUsagesUnit["Count"] = "Count";
+    /** Bytes */
+    KnownUsagesUnit["Bytes"] = "Bytes";
+    /** Seconds */
+    KnownUsagesUnit["Seconds"] = "Seconds";
+    /** Percent */
+    KnownUsagesUnit["Percent"] = "Percent";
+    /** CountPerSecond */
+    KnownUsagesUnit["CountPerSecond"] = "CountPerSecond";
+    /** BytesPerSecond */
+    KnownUsagesUnit["BytesPerSecond"] = "BytesPerSecond";
+})(KnownUsagesUnit || (KnownUsagesUnit = {}));
+export function nameInfoDeserializer(item) {
+    return {
+        value: item["value"],
+        localizedValue: item["localizedValue"],
+    };
+}
+export function vaultExtendedInfoResourceSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : vaultExtendedInfoSerializer(item["properties"]),
+        etag: item["etag"],
+    };
+}
+export function vaultExtendedInfoResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : vaultExtendedInfoDeserializer(item["properties"]),
+        etag: item["etag"],
+    };
+}
+export function vaultExtendedInfoSerializer(item) {
+    return {
+        integrityKey: item["integrityKey"],
+        encryptionKey: item["encryptionKey"],
+        encryptionKeyThumbprint: item["encryptionKeyThumbprint"],
+        algorithm: item["algorithm"],
+    };
+}
+export function vaultExtendedInfoDeserializer(item) {
+    return {
+        integrityKey: item["integrityKey"],
+        encryptionKey: item["encryptionKey"],
+        encryptionKeyThumbprint: item["encryptionKeyThumbprint"],
+        algorithm: item["algorithm"],
+    };
+}
+export function checkNameAvailabilityParametersSerializer(item) {
+    return { type: item["type"], name: item["name"] };
+}
+export function checkNameAvailabilityResultDeserializer(item) {
+    return {
+        nameAvailable: item["nameAvailable"],
+        reason: item["reason"],
+        message: item["message"],
+    };
+}
+export function resourceCapabilitiesSerializer(item) {
+    return {
+        type: item["type"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : capabilitiesPropertiesSerializer(item["properties"]),
+    };
+}
+export function capabilitiesPropertiesSerializer(item) {
+    return {
+        dnsZones: !item["dnsZones"] ? item["dnsZones"] : dnsZoneArraySerializer(item["dnsZones"]),
+    };
+}
+export function dnsZoneArraySerializer(result) {
+    return result.map((item) => {
+        return dnsZoneSerializer(item);
+    });
+}
+export function dnsZoneArrayDeserializer(result) {
+    return result.map((item) => {
+        return dnsZoneDeserializer(item);
+    });
+}
+export function dnsZoneSerializer(item) {
+    return { subResource: item["subResource"] };
+}
+export function dnsZoneDeserializer(item) {
+    return {
+        subResource: item["subResource"],
+    };
+}
+export function resourceCapabilitiesBaseSerializer(item) {
+    return { type: item["type"] };
+}
+export function resourceCapabilitiesBaseDeserializer(item) {
+    return {
+        type: item["type"],
+    };
+}
+export function capabilitiesResponseDeserializer(item) {
+    return {
+        type: item["type"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : capabilitiesResponsePropertiesDeserializer(item["properties"]),
+    };
+}
+export function capabilitiesResponsePropertiesDeserializer(item) {
+    return {
+        dnsZones: !item["dnsZones"]
+            ? item["dnsZones"]
+            : dnsZoneResponseArrayDeserializer(item["dnsZones"]),
+    };
+}
+export function dnsZoneResponseArrayDeserializer(result) {
+    return result.map((item) => {
+        return dnsZoneResponseDeserializer(item);
+    });
+}
+export function dnsZoneResponseDeserializer(item) {
+    return {
+        subResource: item["subResource"],
+        requiredZoneNames: !item["requiredZoneNames"]
+            ? item["requiredZoneNames"]
+            : item["requiredZoneNames"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** The available API versions. */
+export var KnownVersions;
+(function (KnownVersions) {
+    /** The 2025-02-01 API version. */
+    KnownVersions["V20250201"] = "2025-02-01";
+    /** The 2025-08-01 API version. */
+    KnownVersions["V20250801"] = "2025-08-01";
+})(KnownVersions || (KnownVersions = {}));
+//# sourceMappingURL=models.js.map