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

package/dist/commonjs/models/models.js

@@ -0,0 +1,1439 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownVersions = exports.KnownUsagesUnit = exports.KnownAuthType = exports.KnownCreatedByType = exports.KnownSkuName = exports.KnownResourceIdentityType = exports.KnownBcdrSecurityLevel = exports.KnownSecureScoreLevel = exports.KnownIdentityType = exports.KnownState = exports.KnownMultiUserAuthorization = exports.KnownEnhancedSecurityState = exports.KnownSoftDeleteState = exports.KnownImmutabilityState = exports.KnownCrossRegionRestore = exports.KnownStandardTierStorageRedundancy = exports.KnownCrossSubscriptionRestoreState = exports.KnownAlertsState = exports.KnownPublicNetworkAccess = exports.KnownBackupStorageVersion = exports.KnownResourceMoveState = exports.KnownInfrastructureEncryptionState = exports.KnownVaultPrivateEndpointState = exports.KnownVaultSubResourceType = exports.KnownPrivateEndpointConnectionStatus = exports.KnownProvisioningState = exports.KnownTriggerType = exports.KnownVaultUpgradeState = void 0;
+exports.operationResourceDeserializer = operationResourceDeserializer;
+exports.errorDeserializer = errorDeserializer;
+exports.errorAdditionalInfoArrayDeserializer = errorAdditionalInfoArrayDeserializer;
+exports.errorAdditionalInfoDeserializer = errorAdditionalInfoDeserializer;
+exports.errorArrayDeserializer = errorArrayDeserializer;
+exports.cloudErrorDeserializer = cloudErrorDeserializer;
+exports.vaultSerializer = vaultSerializer;
+exports.vaultDeserializer = vaultDeserializer;
+exports.vaultPropertiesSerializer = vaultPropertiesSerializer;
+exports.vaultPropertiesDeserializer = vaultPropertiesDeserializer;
+exports.upgradeDetailsSerializer = upgradeDetailsSerializer;
+exports.upgradeDetailsDeserializer = upgradeDetailsDeserializer;
+exports.privateEndpointConnectionVaultPropertiesArrayDeserializer = privateEndpointConnectionVaultPropertiesArrayDeserializer;
+exports.privateEndpointConnectionVaultPropertiesDeserializer = privateEndpointConnectionVaultPropertiesDeserializer;
+exports.privateEndpointConnectionDeserializer = privateEndpointConnectionDeserializer;
+exports.privateEndpointDeserializer = privateEndpointDeserializer;
+exports.privateLinkServiceConnectionStateDeserializer = privateLinkServiceConnectionStateDeserializer;
+exports.vaultPropertiesEncryptionSerializer = vaultPropertiesEncryptionSerializer;
+exports.vaultPropertiesEncryptionDeserializer = vaultPropertiesEncryptionDeserializer;
+exports.cmkKeyVaultPropertiesSerializer = cmkKeyVaultPropertiesSerializer;
+exports.cmkKeyVaultPropertiesDeserializer = cmkKeyVaultPropertiesDeserializer;
+exports.cmkKekIdentitySerializer = cmkKekIdentitySerializer;
+exports.cmkKekIdentityDeserializer = cmkKekIdentityDeserializer;
+exports.vaultPropertiesMoveDetailsSerializer = vaultPropertiesMoveDetailsSerializer;
+exports.vaultPropertiesMoveDetailsDeserializer = vaultPropertiesMoveDetailsDeserializer;
+exports.monitoringSettingsSerializer = monitoringSettingsSerializer;
+exports.monitoringSettingsDeserializer = monitoringSettingsDeserializer;
+exports.azureMonitorAlertSettingsSerializer = azureMonitorAlertSettingsSerializer;
+exports.azureMonitorAlertSettingsDeserializer = azureMonitorAlertSettingsDeserializer;
+exports.classicAlertSettingsSerializer = classicAlertSettingsSerializer;
+exports.classicAlertSettingsDeserializer = classicAlertSettingsDeserializer;
+exports.restoreSettingsSerializer = restoreSettingsSerializer;
+exports.restoreSettingsDeserializer = restoreSettingsDeserializer;
+exports.crossSubscriptionRestoreSettingsSerializer = crossSubscriptionRestoreSettingsSerializer;
+exports.crossSubscriptionRestoreSettingsDeserializer = crossSubscriptionRestoreSettingsDeserializer;
+exports.vaultPropertiesRedundancySettingsSerializer = vaultPropertiesRedundancySettingsSerializer;
+exports.vaultPropertiesRedundancySettingsDeserializer = vaultPropertiesRedundancySettingsDeserializer;
+exports.securitySettingsSerializer = securitySettingsSerializer;
+exports.securitySettingsDeserializer = securitySettingsDeserializer;
+exports.immutabilitySettingsSerializer = immutabilitySettingsSerializer;
+exports.immutabilitySettingsDeserializer = immutabilitySettingsDeserializer;
+exports.softDeleteSettingsSerializer = softDeleteSettingsSerializer;
+exports.softDeleteSettingsDeserializer = softDeleteSettingsDeserializer;
+exports.sourceScanConfigurationSerializer = sourceScanConfigurationSerializer;
+exports.sourceScanConfigurationDeserializer = sourceScanConfigurationDeserializer;
+exports.associatedIdentitySerializer = associatedIdentitySerializer;
+exports.associatedIdentityDeserializer = associatedIdentityDeserializer;
+exports.identityDataSerializer = identityDataSerializer;
+exports.identityDataDeserializer = identityDataDeserializer;
+exports.userIdentityRecordSerializer = userIdentityRecordSerializer;
+exports.userIdentityRecordDeserializer = userIdentityRecordDeserializer;
+exports.userIdentitySerializer = userIdentitySerializer;
+exports.userIdentityDeserializer = userIdentityDeserializer;
+exports.skuSerializer = skuSerializer;
+exports.skuDeserializer = skuDeserializer;
+exports.trackedResourceSerializer = trackedResourceSerializer;
+exports.trackedResourceDeserializer = trackedResourceDeserializer;
+exports.resourceSerializer = resourceSerializer;
+exports.resourceDeserializer = resourceDeserializer;
+exports.systemDataDeserializer = systemDataDeserializer;
+exports._clientDiscoveryResponseDeserializer = _clientDiscoveryResponseDeserializer;
+exports.clientDiscoveryValueForSingleApiArrayDeserializer = clientDiscoveryValueForSingleApiArrayDeserializer;
+exports.clientDiscoveryValueForSingleApiDeserializer = clientDiscoveryValueForSingleApiDeserializer;
+exports.clientDiscoveryDisplayDeserializer = clientDiscoveryDisplayDeserializer;
+exports.clientDiscoveryForPropertiesDeserializer = clientDiscoveryForPropertiesDeserializer;
+exports.clientDiscoveryForServiceSpecificationDeserializer = clientDiscoveryForServiceSpecificationDeserializer;
+exports.clientDiscoveryForLogSpecificationArrayDeserializer = clientDiscoveryForLogSpecificationArrayDeserializer;
+exports.clientDiscoveryForLogSpecificationDeserializer = clientDiscoveryForLogSpecificationDeserializer;
+exports.errorDetailDeserializer = errorDetailDeserializer;
+exports.errorDetailArrayDeserializer = errorDetailArrayDeserializer;
+exports.patchVaultSerializer = patchVaultSerializer;
+exports.patchTrackedResourceSerializer = patchTrackedResourceSerializer;
+exports.errorResponseDeserializer = errorResponseDeserializer;
+exports._vaultListDeserializer = _vaultListDeserializer;
+exports.vaultArraySerializer = vaultArraySerializer;
+exports.vaultArrayDeserializer = vaultArrayDeserializer;
+exports._deletedVaultListDeserializer = _deletedVaultListDeserializer;
+exports.deletedVaultArrayDeserializer = deletedVaultArrayDeserializer;
+exports.deletedVaultDeserializer = deletedVaultDeserializer;
+exports.deletedVaultPropertiesDeserializer = deletedVaultPropertiesDeserializer;
+exports.proxyResourceSerializer = proxyResourceSerializer;
+exports.proxyResourceDeserializer = proxyResourceDeserializer;
+exports.deletedVaultUndeleteInputSerializer = deletedVaultUndeleteInputSerializer;
+exports.deletedVaultUndeleteInputPropertiesSerializer = deletedVaultUndeleteInputPropertiesSerializer;
+exports.privateLinkResourceDeserializer = privateLinkResourceDeserializer;
+exports.privateLinkResourcePropertiesDeserializer = privateLinkResourcePropertiesDeserializer;
+exports._privateLinkResourcesDeserializer = _privateLinkResourcesDeserializer;
+exports.privateLinkResourceArrayDeserializer = privateLinkResourceArrayDeserializer;
+exports.certificateRequestSerializer = certificateRequestSerializer;
+exports.rawCertificateDataSerializer = rawCertificateDataSerializer;
+exports.vaultCertificateResponseDeserializer = vaultCertificateResponseDeserializer;
+exports.resourceCertificateDetailsDeserializer = resourceCertificateDetailsDeserializer;
+exports.resourceCertificateDetailsUnionDeserializer = resourceCertificateDetailsUnionDeserializer;
+exports.resourceCertificateAndAadDetailsDeserializer = resourceCertificateAndAadDetailsDeserializer;
+exports.resourceCertificateAndAcsDetailsDeserializer = resourceCertificateAndAcsDetailsDeserializer;
+exports._replicationUsageListDeserializer = _replicationUsageListDeserializer;
+exports.replicationUsageArrayDeserializer = replicationUsageArrayDeserializer;
+exports.replicationUsageDeserializer = replicationUsageDeserializer;
+exports.monitoringSummaryDeserializer = monitoringSummaryDeserializer;
+exports.jobsSummaryDeserializer = jobsSummaryDeserializer;
+exports._vaultUsageListDeserializer = _vaultUsageListDeserializer;
+exports.vaultUsageArrayDeserializer = vaultUsageArrayDeserializer;
+exports.vaultUsageDeserializer = vaultUsageDeserializer;
+exports.nameInfoDeserializer = nameInfoDeserializer;
+exports.vaultExtendedInfoResourceSerializer = vaultExtendedInfoResourceSerializer;
+exports.vaultExtendedInfoResourceDeserializer = vaultExtendedInfoResourceDeserializer;
+exports.vaultExtendedInfoSerializer = vaultExtendedInfoSerializer;
+exports.vaultExtendedInfoDeserializer = vaultExtendedInfoDeserializer;
+exports.checkNameAvailabilityParametersSerializer = checkNameAvailabilityParametersSerializer;
+exports.checkNameAvailabilityResultDeserializer = checkNameAvailabilityResultDeserializer;
+exports.resourceCapabilitiesSerializer = resourceCapabilitiesSerializer;
+exports.capabilitiesPropertiesSerializer = capabilitiesPropertiesSerializer;
+exports.dnsZoneArraySerializer = dnsZoneArraySerializer;
+exports.dnsZoneArrayDeserializer = dnsZoneArrayDeserializer;
+exports.dnsZoneSerializer = dnsZoneSerializer;
+exports.dnsZoneDeserializer = dnsZoneDeserializer;
+exports.resourceCapabilitiesBaseSerializer = resourceCapabilitiesBaseSerializer;
+exports.resourceCapabilitiesBaseDeserializer = resourceCapabilitiesBaseDeserializer;
+exports.capabilitiesResponseDeserializer = capabilitiesResponseDeserializer;
+exports.capabilitiesResponsePropertiesDeserializer = capabilitiesResponsePropertiesDeserializer;
+exports.dnsZoneResponseArrayDeserializer = dnsZoneResponseArrayDeserializer;
+exports.dnsZoneResponseDeserializer = dnsZoneResponseDeserializer;
+const core_util_1 = require("@azure/core-util");
+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"]),
+    };
+}
+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"],
+    };
+}
+function errorAdditionalInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorAdditionalInfoDeserializer(item);
+    });
+}
+function errorAdditionalInfoDeserializer(item) {
+    return {
+        type: item["type"],
+        info: item["info"],
+    };
+}
+function errorArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorDeserializer(item);
+    });
+}
+function cloudErrorDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDeserializer(item["error"]),
+    };
+}
+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"],
+    };
+}
+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"],
+    };
+}
+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;
+            }),
+    };
+}
+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;
+            }),
+    };
+}
+function upgradeDetailsSerializer(item) {
+    return item;
+}
+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. */
+var KnownVaultUpgradeState;
+(function (KnownVaultUpgradeState) {
+    /** Unknown */
+    KnownVaultUpgradeState["Unknown"] = "Unknown";
+    /** InProgress */
+    KnownVaultUpgradeState["InProgress"] = "InProgress";
+    /** Upgraded */
+    KnownVaultUpgradeState["Upgraded"] = "Upgraded";
+    /** Failed */
+    KnownVaultUpgradeState["Failed"] = "Failed";
+})(KnownVaultUpgradeState || (exports.KnownVaultUpgradeState = KnownVaultUpgradeState = {}));
+/** The way the vault upgrade was triggered. */
+var KnownTriggerType;
+(function (KnownTriggerType) {
+    /** UserTriggered */
+    KnownTriggerType["UserTriggered"] = "UserTriggered";
+    /** ForcedUpgrade */
+    KnownTriggerType["ForcedUpgrade"] = "ForcedUpgrade";
+})(KnownTriggerType || (exports.KnownTriggerType = KnownTriggerType = {}));
+function privateEndpointConnectionVaultPropertiesArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionVaultPropertiesDeserializer(item);
+    });
+}
+function privateEndpointConnectionVaultPropertiesDeserializer(item) {
+    return {
+        id: item["id"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : privateEndpointConnectionDeserializer(item["properties"]),
+        name: item["name"],
+        type: item["type"],
+        location: item["location"],
+    };
+}
+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. */
+var KnownProvisioningState;
+(function (KnownProvisioningState) {
+    /** Succeeded */
+    KnownProvisioningState["Succeeded"] = "Succeeded";
+    /** Deleting */
+    KnownProvisioningState["Deleting"] = "Deleting";
+    /** Failed */
+    KnownProvisioningState["Failed"] = "Failed";
+    /** Pending */
+    KnownProvisioningState["Pending"] = "Pending";
+})(KnownProvisioningState || (exports.KnownProvisioningState = KnownProvisioningState = {}));
+function privateEndpointDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+function privateLinkServiceConnectionStateDeserializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+/** Gets or sets the status. */
+var KnownPrivateEndpointConnectionStatus;
+(function (KnownPrivateEndpointConnectionStatus) {
+    /** Pending */
+    KnownPrivateEndpointConnectionStatus["Pending"] = "Pending";
+    /** Approved */
+    KnownPrivateEndpointConnectionStatus["Approved"] = "Approved";
+    /** Rejected */
+    KnownPrivateEndpointConnectionStatus["Rejected"] = "Rejected";
+    /** Disconnected */
+    KnownPrivateEndpointConnectionStatus["Disconnected"] = "Disconnected";
+})(KnownPrivateEndpointConnectionStatus || (exports.KnownPrivateEndpointConnectionStatus = KnownPrivateEndpointConnectionStatus = {}));
+/** Subresource type for vault AzureBackup, AzureBackup_secondary or AzureSiteRecovery */
+var KnownVaultSubResourceType;
+(function (KnownVaultSubResourceType) {
+    /** AzureBackup */
+    KnownVaultSubResourceType["AzureBackup"] = "AzureBackup";
+    /** AzureBackup_secondary */
+    KnownVaultSubResourceType["AzureBackupSecondary"] = "AzureBackup_secondary";
+    /** AzureSiteRecovery */
+    KnownVaultSubResourceType["AzureSiteRecovery"] = "AzureSiteRecovery";
+})(KnownVaultSubResourceType || (exports.KnownVaultSubResourceType = KnownVaultSubResourceType = {}));
+/** Private endpoint state for backup. */
+var KnownVaultPrivateEndpointState;
+(function (KnownVaultPrivateEndpointState) {
+    /** None */
+    KnownVaultPrivateEndpointState["None"] = "None";
+    /** Enabled */
+    KnownVaultPrivateEndpointState["Enabled"] = "Enabled";
+})(KnownVaultPrivateEndpointState || (exports.KnownVaultPrivateEndpointState = KnownVaultPrivateEndpointState = {}));
+function vaultPropertiesEncryptionSerializer(item) {
+    return {
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : cmkKeyVaultPropertiesSerializer(item["keyVaultProperties"]),
+        kekIdentity: !item["kekIdentity"]
+            ? item["kekIdentity"]
+            : cmkKekIdentitySerializer(item["kekIdentity"]),
+        infrastructureEncryption: item["infrastructureEncryption"],
+    };
+}
+function vaultPropertiesEncryptionDeserializer(item) {
+    return {
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : cmkKeyVaultPropertiesDeserializer(item["keyVaultProperties"]),
+        kekIdentity: !item["kekIdentity"]
+            ? item["kekIdentity"]
+            : cmkKekIdentityDeserializer(item["kekIdentity"]),
+        infrastructureEncryption: item["infrastructureEncryption"],
+    };
+}
+function cmkKeyVaultPropertiesSerializer(item) {
+    return { keyUri: item["keyUri"] };
+}
+function cmkKeyVaultPropertiesDeserializer(item) {
+    return {
+        keyUri: item["keyUri"],
+    };
+}
+function cmkKekIdentitySerializer(item) {
+    return {
+        useSystemAssignedIdentity: item["useSystemAssignedIdentity"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+function cmkKekIdentityDeserializer(item) {
+    return {
+        useSystemAssignedIdentity: item["useSystemAssignedIdentity"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+/** Enabling/Disabling the Double Encryption state */
+var KnownInfrastructureEncryptionState;
+(function (KnownInfrastructureEncryptionState) {
+    /** Enabled */
+    KnownInfrastructureEncryptionState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownInfrastructureEncryptionState["Disabled"] = "Disabled";
+})(KnownInfrastructureEncryptionState || (exports.KnownInfrastructureEncryptionState = KnownInfrastructureEncryptionState = {}));
+function vaultPropertiesMoveDetailsSerializer(item) {
+    return item;
+}
+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 */
+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 || (exports.KnownResourceMoveState = KnownResourceMoveState = {}));
+/** Backup storage version */
+var KnownBackupStorageVersion;
+(function (KnownBackupStorageVersion) {
+    /** V1 */
+    KnownBackupStorageVersion["V1"] = "V1";
+    /** V2 */
+    KnownBackupStorageVersion["V2"] = "V2";
+    /** Unassigned */
+    KnownBackupStorageVersion["Unassigned"] = "Unassigned";
+})(KnownBackupStorageVersion || (exports.KnownBackupStorageVersion = KnownBackupStorageVersion = {}));
+/** property to enable or disable resource provider inbound network traffic from public clients */
+var KnownPublicNetworkAccess;
+(function (KnownPublicNetworkAccess) {
+    /** Enabled */
+    KnownPublicNetworkAccess["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownPublicNetworkAccess["Disabled"] = "Disabled";
+})(KnownPublicNetworkAccess || (exports.KnownPublicNetworkAccess = KnownPublicNetworkAccess = {}));
+function monitoringSettingsSerializer(item) {
+    return {
+        azureMonitorAlertSettings: !item["azureMonitorAlertSettings"]
+            ? item["azureMonitorAlertSettings"]
+            : azureMonitorAlertSettingsSerializer(item["azureMonitorAlertSettings"]),
+        classicAlertSettings: !item["classicAlertSettings"]
+            ? item["classicAlertSettings"]
+            : classicAlertSettingsSerializer(item["classicAlertSettings"]),
+    };
+}
+function monitoringSettingsDeserializer(item) {
+    return {
+        azureMonitorAlertSettings: !item["azureMonitorAlertSettings"]
+            ? item["azureMonitorAlertSettings"]
+            : azureMonitorAlertSettingsDeserializer(item["azureMonitorAlertSettings"]),
+        classicAlertSettings: !item["classicAlertSettings"]
+            ? item["classicAlertSettings"]
+            : classicAlertSettingsDeserializer(item["classicAlertSettings"]),
+    };
+}
+function azureMonitorAlertSettingsSerializer(item) {
+    return {
+        alertsForAllJobFailures: item["alertsForAllJobFailures"],
+        alertsForAllReplicationIssues: item["alertsForAllReplicationIssues"],
+        alertsForAllFailoverIssues: item["alertsForAllFailoverIssues"],
+    };
+}
+function azureMonitorAlertSettingsDeserializer(item) {
+    return {
+        alertsForAllJobFailures: item["alertsForAllJobFailures"],
+        alertsForAllReplicationIssues: item["alertsForAllReplicationIssues"],
+        alertsForAllFailoverIssues: item["alertsForAllFailoverIssues"],
+    };
+}
+/** Known values of {@link AlertsState} that the service accepts. */
+var KnownAlertsState;
+(function (KnownAlertsState) {
+    /** Enabled */
+    KnownAlertsState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownAlertsState["Disabled"] = "Disabled";
+})(KnownAlertsState || (exports.KnownAlertsState = KnownAlertsState = {}));
+function classicAlertSettingsSerializer(item) {
+    return {
+        alertsForCriticalOperations: item["alertsForCriticalOperations"],
+        emailNotificationsForSiteRecovery: item["emailNotificationsForSiteRecovery"],
+    };
+}
+function classicAlertSettingsDeserializer(item) {
+    return {
+        alertsForCriticalOperations: item["alertsForCriticalOperations"],
+        emailNotificationsForSiteRecovery: item["emailNotificationsForSiteRecovery"],
+    };
+}
+function restoreSettingsSerializer(item) {
+    return {
+        crossSubscriptionRestoreSettings: !item["crossSubscriptionRestoreSettings"]
+            ? item["crossSubscriptionRestoreSettings"]
+            : crossSubscriptionRestoreSettingsSerializer(item["crossSubscriptionRestoreSettings"]),
+    };
+}
+function restoreSettingsDeserializer(item) {
+    return {
+        crossSubscriptionRestoreSettings: !item["crossSubscriptionRestoreSettings"]
+            ? item["crossSubscriptionRestoreSettings"]
+            : crossSubscriptionRestoreSettingsDeserializer(item["crossSubscriptionRestoreSettings"]),
+    };
+}
+function crossSubscriptionRestoreSettingsSerializer(item) {
+    return {
+        crossSubscriptionRestoreState: item["crossSubscriptionRestoreState"],
+    };
+}
+function crossSubscriptionRestoreSettingsDeserializer(item) {
+    return {
+        crossSubscriptionRestoreState: item["crossSubscriptionRestoreState"],
+    };
+}
+/** Known values of {@link CrossSubscriptionRestoreState} that the service accepts. */
+var KnownCrossSubscriptionRestoreState;
+(function (KnownCrossSubscriptionRestoreState) {
+    /** Enabled */
+    KnownCrossSubscriptionRestoreState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownCrossSubscriptionRestoreState["Disabled"] = "Disabled";
+    /** PermanentlyDisabled */
+    KnownCrossSubscriptionRestoreState["PermanentlyDisabled"] = "PermanentlyDisabled";
+})(KnownCrossSubscriptionRestoreState || (exports.KnownCrossSubscriptionRestoreState = KnownCrossSubscriptionRestoreState = {}));
+function vaultPropertiesRedundancySettingsSerializer(item) {
+    return {
+        standardTierStorageRedundancy: item["standardTierStorageRedundancy"],
+        crossRegionRestore: item["crossRegionRestore"],
+    };
+}
+function vaultPropertiesRedundancySettingsDeserializer(item) {
+    return {
+        standardTierStorageRedundancy: item["standardTierStorageRedundancy"],
+        crossRegionRestore: item["crossRegionRestore"],
+    };
+}
+/** The storage redundancy setting of a vault */
+var KnownStandardTierStorageRedundancy;
+(function (KnownStandardTierStorageRedundancy) {
+    /** Invalid */
+    KnownStandardTierStorageRedundancy["Invalid"] = "Invalid";
+    /** LocallyRedundant */
+    KnownStandardTierStorageRedundancy["LocallyRedundant"] = "LocallyRedundant";
+    /** GeoRedundant */
+    KnownStandardTierStorageRedundancy["GeoRedundant"] = "GeoRedundant";
+    /** ZoneRedundant */
+    KnownStandardTierStorageRedundancy["ZoneRedundant"] = "ZoneRedundant";
+})(KnownStandardTierStorageRedundancy || (exports.KnownStandardTierStorageRedundancy = KnownStandardTierStorageRedundancy = {}));
+/** Flag to show if Cross Region Restore is enabled on the Vault or not */
+var KnownCrossRegionRestore;
+(function (KnownCrossRegionRestore) {
+    /** Enabled */
+    KnownCrossRegionRestore["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownCrossRegionRestore["Disabled"] = "Disabled";
+})(KnownCrossRegionRestore || (exports.KnownCrossRegionRestore = KnownCrossRegionRestore = {}));
+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"]),
+    };
+}
+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"]),
+    };
+}
+function immutabilitySettingsSerializer(item) {
+    return { state: item["state"] };
+}
+function immutabilitySettingsDeserializer(item) {
+    return {
+        state: item["state"],
+    };
+}
+/** Known values of {@link ImmutabilityState} that the service accepts. */
+var KnownImmutabilityState;
+(function (KnownImmutabilityState) {
+    /** Disabled */
+    KnownImmutabilityState["Disabled"] = "Disabled";
+    /** Unlocked */
+    KnownImmutabilityState["Unlocked"] = "Unlocked";
+    /** Locked */
+    KnownImmutabilityState["Locked"] = "Locked";
+})(KnownImmutabilityState || (exports.KnownImmutabilityState = KnownImmutabilityState = {}));
+function softDeleteSettingsSerializer(item) {
+    return {
+        softDeleteState: item["softDeleteState"],
+        softDeleteRetentionPeriodInDays: item["softDeleteRetentionPeriodInDays"],
+        enhancedSecurityState: item["enhancedSecurityState"],
+    };
+}
+function softDeleteSettingsDeserializer(item) {
+    return {
+        softDeleteState: item["softDeleteState"],
+        softDeleteRetentionPeriodInDays: item["softDeleteRetentionPeriodInDays"],
+        enhancedSecurityState: item["enhancedSecurityState"],
+    };
+}
+/** Known values of {@link SoftDeleteState} that the service accepts. */
+var KnownSoftDeleteState;
+(function (KnownSoftDeleteState) {
+    /** Invalid */
+    KnownSoftDeleteState["Invalid"] = "Invalid";
+    /** Enabled */
+    KnownSoftDeleteState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownSoftDeleteState["Disabled"] = "Disabled";
+    /** AlwaysON */
+    KnownSoftDeleteState["AlwaysON"] = "AlwaysON";
+})(KnownSoftDeleteState || (exports.KnownSoftDeleteState = KnownSoftDeleteState = {}));
+/** Known values of {@link EnhancedSecurityState} that the service accepts. */
+var KnownEnhancedSecurityState;
+(function (KnownEnhancedSecurityState) {
+    /** Invalid */
+    KnownEnhancedSecurityState["Invalid"] = "Invalid";
+    /** Enabled */
+    KnownEnhancedSecurityState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownEnhancedSecurityState["Disabled"] = "Disabled";
+    /** AlwaysON */
+    KnownEnhancedSecurityState["AlwaysON"] = "AlwaysON";
+})(KnownEnhancedSecurityState || (exports.KnownEnhancedSecurityState = KnownEnhancedSecurityState = {}));
+/** MUA Settings of vault */
+var KnownMultiUserAuthorization;
+(function (KnownMultiUserAuthorization) {
+    /** Invalid */
+    KnownMultiUserAuthorization["Invalid"] = "Invalid";
+    /** Enabled */
+    KnownMultiUserAuthorization["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownMultiUserAuthorization["Disabled"] = "Disabled";
+})(KnownMultiUserAuthorization || (exports.KnownMultiUserAuthorization = KnownMultiUserAuthorization = {}));
+function sourceScanConfigurationSerializer(item) {
+    return {
+        state: item["state"],
+        sourceScanIdentity: !item["sourceScanIdentity"]
+            ? item["sourceScanIdentity"]
+            : associatedIdentitySerializer(item["sourceScanIdentity"]),
+    };
+}
+function sourceScanConfigurationDeserializer(item) {
+    return {
+        state: item["state"],
+        sourceScanIdentity: !item["sourceScanIdentity"]
+            ? item["sourceScanIdentity"]
+            : associatedIdentityDeserializer(item["sourceScanIdentity"]),
+    };
+}
+/** Known values of {@link State} that the service accepts. */
+var KnownState;
+(function (KnownState) {
+    /** Invalid */
+    KnownState["Invalid"] = "Invalid";
+    /** Enabled */
+    KnownState["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownState["Disabled"] = "Disabled";
+})(KnownState || (exports.KnownState = KnownState = {}));
+function associatedIdentitySerializer(item) {
+    return {
+        operationIdentityType: item["operationIdentityType"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+function associatedIdentityDeserializer(item) {
+    return {
+        operationIdentityType: item["operationIdentityType"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+/** Identity type that should be used for an operation. */
+var KnownIdentityType;
+(function (KnownIdentityType) {
+    /** SystemAssigned */
+    KnownIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** UserAssigned */
+    KnownIdentityType["UserAssigned"] = "UserAssigned";
+})(KnownIdentityType || (exports.KnownIdentityType = KnownIdentityType = {}));
+/** Secure Score of Recovery Services Vault */
+var KnownSecureScoreLevel;
+(function (KnownSecureScoreLevel) {
+    /** None */
+    KnownSecureScoreLevel["None"] = "None";
+    /** Minimum */
+    KnownSecureScoreLevel["Minimum"] = "Minimum";
+    /** Adequate */
+    KnownSecureScoreLevel["Adequate"] = "Adequate";
+    /** Maximum */
+    KnownSecureScoreLevel["Maximum"] = "Maximum";
+})(KnownSecureScoreLevel || (exports.KnownSecureScoreLevel = KnownSecureScoreLevel = {}));
+/** Security levels of Recovery Services Vault for business continuity and disaster recovery */
+var KnownBcdrSecurityLevel;
+(function (KnownBcdrSecurityLevel) {
+    /** Poor */
+    KnownBcdrSecurityLevel["Poor"] = "Poor";
+    /** Fair */
+    KnownBcdrSecurityLevel["Fair"] = "Fair";
+    /** Good */
+    KnownBcdrSecurityLevel["Good"] = "Good";
+    /** Excellent */
+    KnownBcdrSecurityLevel["Excellent"] = "Excellent";
+})(KnownBcdrSecurityLevel || (exports.KnownBcdrSecurityLevel = KnownBcdrSecurityLevel = {}));
+function identityDataSerializer(item) {
+    return {
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userIdentityRecordSerializer(item["userAssignedIdentities"]),
+    };
+}
+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. */
+var KnownResourceIdentityType;
+(function (KnownResourceIdentityType) {
+    /** SystemAssigned */
+    KnownResourceIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** None */
+    KnownResourceIdentityType["None"] = "None";
+    /** UserAssigned */
+    KnownResourceIdentityType["UserAssigned"] = "UserAssigned";
+    /** SystemAssigned, UserAssigned */
+    KnownResourceIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned, UserAssigned";
+})(KnownResourceIdentityType || (exports.KnownResourceIdentityType = KnownResourceIdentityType = {}));
+function userIdentityRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userIdentitySerializer(item[key]);
+    });
+    return result;
+}
+function userIdentityRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userIdentityDeserializer(item[key]);
+    });
+    return result;
+}
+function userIdentitySerializer(item) {
+    return item;
+}
+function userIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+function skuSerializer(item) {
+    return {
+        name: item["name"],
+        tier: item["tier"],
+        family: item["family"],
+        size: item["size"],
+        capacity: item["capacity"],
+    };
+}
+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 */
+var KnownSkuName;
+(function (KnownSkuName) {
+    /** Standard */
+    KnownSkuName["Standard"] = "Standard";
+    /** RS0 */
+    KnownSkuName["RS0"] = "RS0";
+})(KnownSkuName || (exports.KnownSkuName = KnownSkuName = {}));
+function trackedResourceSerializer(item) {
+    return { tags: item["tags"], location: item["location"] };
+}
+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"],
+    };
+}
+function resourceSerializer(item) {
+    return item;
+}
+function resourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+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. */
+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 || (exports.KnownCreatedByType = KnownCreatedByType = {}));
+function _clientDiscoveryResponseDeserializer(item) {
+    return {
+        value: clientDiscoveryValueForSingleApiArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function clientDiscoveryValueForSingleApiArrayDeserializer(result) {
+    return result.map((item) => {
+        return clientDiscoveryValueForSingleApiDeserializer(item);
+    });
+}
+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"]),
+    };
+}
+function clientDiscoveryDisplayDeserializer(item) {
+    return {
+        provider: item["provider"],
+        resource: item["resource"],
+        operation: item["operation"],
+        description: item["description"],
+    };
+}
+function clientDiscoveryForPropertiesDeserializer(item) {
+    return {
+        serviceSpecification: !item["serviceSpecification"]
+            ? item["serviceSpecification"]
+            : clientDiscoveryForServiceSpecificationDeserializer(item["serviceSpecification"]),
+    };
+}
+function clientDiscoveryForServiceSpecificationDeserializer(item) {
+    return {
+        logSpecifications: !item["logSpecifications"]
+            ? item["logSpecifications"]
+            : clientDiscoveryForLogSpecificationArrayDeserializer(item["logSpecifications"]),
+    };
+}
+function clientDiscoveryForLogSpecificationArrayDeserializer(result) {
+    return result.map((item) => {
+        return clientDiscoveryForLogSpecificationDeserializer(item);
+    });
+}
+function clientDiscoveryForLogSpecificationDeserializer(item) {
+    return {
+        name: item["name"],
+        displayName: item["displayName"],
+        blobDuration: item["blobDuration"],
+    };
+}
+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"]),
+    };
+}
+function errorDetailArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorDetailDeserializer(item);
+    });
+}
+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"]),
+    };
+}
+function patchTrackedResourceSerializer(item) {
+    return { location: item["location"], tags: item["tags"], etag: item["etag"] };
+}
+function errorResponseDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"]),
+    };
+}
+function _vaultListDeserializer(item) {
+    return {
+        value: vaultArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function vaultArraySerializer(result) {
+    return result.map((item) => {
+        return vaultSerializer(item);
+    });
+}
+function vaultArrayDeserializer(result) {
+    return result.map((item) => {
+        return vaultDeserializer(item);
+    });
+}
+function _deletedVaultListDeserializer(item) {
+    return {
+        value: deletedVaultArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function deletedVaultArrayDeserializer(result) {
+    return result.map((item) => {
+        return deletedVaultDeserializer(item);
+    });
+}
+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"]),
+    };
+}
+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"]),
+    };
+}
+function proxyResourceSerializer(item) {
+    return item;
+}
+function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+function deletedVaultUndeleteInputSerializer(item) {
+    return {
+        properties: deletedVaultUndeleteInputPropertiesSerializer(item["properties"]),
+    };
+}
+function deletedVaultUndeleteInputPropertiesSerializer(item) {
+    return { recoveryResourceGroupId: item["recoveryResourceGroupId"] };
+}
+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"]),
+    };
+}
+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;
+            }),
+    };
+}
+function _privateLinkResourcesDeserializer(item) {
+    return {
+        value: privateLinkResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function privateLinkResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateLinkResourceDeserializer(item);
+    });
+}
+function certificateRequestSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : rawCertificateDataSerializer(item["properties"]),
+    };
+}
+function rawCertificateDataSerializer(item) {
+    return {
+        authType: item["authType"],
+        certificate: !item["certificate"]
+            ? item["certificate"]
+            : (0, core_util_1.uint8ArrayToString)(item["certificate"], "base64"),
+    };
+}
+/** Specifies the authentication type. */
+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 || (exports.KnownAuthType = KnownAuthType = {}));
+function vaultCertificateResponseDeserializer(item) {
+    return {
+        name: item["name"],
+        type: item["type"],
+        id: item["id"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : resourceCertificateDetailsUnionDeserializer(item["properties"]),
+    };
+}
+function resourceCertificateDetailsDeserializer(item) {
+    return {
+        authType: item["authType"],
+        certificate: !item["certificate"]
+            ? item["certificate"]
+            : typeof item["certificate"] === "string"
+                ? (0, core_util_1.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"]),
+    };
+}
+function resourceCertificateDetailsUnionDeserializer(item) {
+    switch (item.authType) {
+        case "AzureActiveDirectory":
+            return resourceCertificateAndAadDetailsDeserializer(item);
+        case "AccessControlService":
+            return resourceCertificateAndAcsDetailsDeserializer(item);
+        default:
+            return resourceCertificateDetailsDeserializer(item);
+    }
+}
+function resourceCertificateAndAadDetailsDeserializer(item) {
+    return {
+        authType: item["authType"],
+        certificate: !item["certificate"]
+            ? item["certificate"]
+            : typeof item["certificate"] === "string"
+                ? (0, core_util_1.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"],
+    };
+}
+function resourceCertificateAndAcsDetailsDeserializer(item) {
+    return {
+        authType: item["authType"],
+        certificate: !item["certificate"]
+            ? item["certificate"]
+            : typeof item["certificate"] === "string"
+                ? (0, core_util_1.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"],
+    };
+}
+function _replicationUsageListDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : replicationUsageArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function replicationUsageArrayDeserializer(result) {
+    return result.map((item) => {
+        return replicationUsageDeserializer(item);
+    });
+}
+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"],
+    };
+}
+function monitoringSummaryDeserializer(item) {
+    return {
+        unHealthyVmCount: item["unHealthyVmCount"],
+        unHealthyProviderCount: item["unHealthyProviderCount"],
+        eventsCount: item["eventsCount"],
+        deprecatedProviderCount: item["deprecatedProviderCount"],
+        supportedProviderCount: item["supportedProviderCount"],
+        unsupportedProviderCount: item["unsupportedProviderCount"],
+    };
+}
+function jobsSummaryDeserializer(item) {
+    return {
+        failedJobs: item["failedJobs"],
+        suspendedJobs: item["suspendedJobs"],
+        inProgressJobs: item["inProgressJobs"],
+    };
+}
+function _vaultUsageListDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : vaultUsageArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+function vaultUsageArrayDeserializer(result) {
+    return result.map((item) => {
+        return vaultUsageDeserializer(item);
+    });
+}
+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. */
+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 || (exports.KnownUsagesUnit = KnownUsagesUnit = {}));
+function nameInfoDeserializer(item) {
+    return {
+        value: item["value"],
+        localizedValue: item["localizedValue"],
+    };
+}
+function vaultExtendedInfoResourceSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : vaultExtendedInfoSerializer(item["properties"]),
+        etag: item["etag"],
+    };
+}
+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"],
+    };
+}
+function vaultExtendedInfoSerializer(item) {
+    return {
+        integrityKey: item["integrityKey"],
+        encryptionKey: item["encryptionKey"],
+        encryptionKeyThumbprint: item["encryptionKeyThumbprint"],
+        algorithm: item["algorithm"],
+    };
+}
+function vaultExtendedInfoDeserializer(item) {
+    return {
+        integrityKey: item["integrityKey"],
+        encryptionKey: item["encryptionKey"],
+        encryptionKeyThumbprint: item["encryptionKeyThumbprint"],
+        algorithm: item["algorithm"],
+    };
+}
+function checkNameAvailabilityParametersSerializer(item) {
+    return { type: item["type"], name: item["name"] };
+}
+function checkNameAvailabilityResultDeserializer(item) {
+    return {
+        nameAvailable: item["nameAvailable"],
+        reason: item["reason"],
+        message: item["message"],
+    };
+}
+function resourceCapabilitiesSerializer(item) {
+    return {
+        type: item["type"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : capabilitiesPropertiesSerializer(item["properties"]),
+    };
+}
+function capabilitiesPropertiesSerializer(item) {
+    return {
+        dnsZones: !item["dnsZones"] ? item["dnsZones"] : dnsZoneArraySerializer(item["dnsZones"]),
+    };
+}
+function dnsZoneArraySerializer(result) {
+    return result.map((item) => {
+        return dnsZoneSerializer(item);
+    });
+}
+function dnsZoneArrayDeserializer(result) {
+    return result.map((item) => {
+        return dnsZoneDeserializer(item);
+    });
+}
+function dnsZoneSerializer(item) {
+    return { subResource: item["subResource"] };
+}
+function dnsZoneDeserializer(item) {
+    return {
+        subResource: item["subResource"],
+    };
+}
+function resourceCapabilitiesBaseSerializer(item) {
+    return { type: item["type"] };
+}
+function resourceCapabilitiesBaseDeserializer(item) {
+    return {
+        type: item["type"],
+    };
+}
+function capabilitiesResponseDeserializer(item) {
+    return {
+        type: item["type"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : capabilitiesResponsePropertiesDeserializer(item["properties"]),
+    };
+}
+function capabilitiesResponsePropertiesDeserializer(item) {
+    return {
+        dnsZones: !item["dnsZones"]
+            ? item["dnsZones"]
+            : dnsZoneResponseArrayDeserializer(item["dnsZones"]),
+    };
+}
+function dnsZoneResponseArrayDeserializer(result) {
+    return result.map((item) => {
+        return dnsZoneResponseDeserializer(item);
+    });
+}
+function dnsZoneResponseDeserializer(item) {
+    return {
+        subResource: item["subResource"],
+        requiredZoneNames: !item["requiredZoneNames"]
+            ? item["requiredZoneNames"]
+            : item["requiredZoneNames"].map((p) => {
+                return p;
+            }),
+    };
+}
+/** The available API versions. */
+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 || (exports.KnownVersions = KnownVersions = {}));
+//# sourceMappingURL=models.js.map