@azure/arm-netapp 23.0.0 → 23.1.0-beta.1

package/dist/browser/models/models.js

@@ -385,6 +385,7 @@ export function volumePropertiesSerializer(item) {
         encryptionKeySource: item["encryptionKeySource"],
         keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
         ldapEnabled: item["ldapEnabled"],
+        ldapServerType: item["ldapServerType"],
         coolAccess: item["coolAccess"],
         coolnessPeriod: item["coolnessPeriod"],
         coolAccessRetrievalPolicy: item["coolAccessRetrievalPolicy"],
@@ -402,6 +403,9 @@ export function volumePropertiesSerializer(item) {
             : placementKeyValuePairsArraySerializer(item["placementRules"]),
         enableSubvolumes: item["enableSubvolumes"],
         isLargeVolume: item["isLargeVolume"],
+        largeVolumeType: item["largeVolumeType"],
+        language: item["language"],
+        breakthroughMode: item["breakthroughMode"],
     };
 }
 export function volumePropertiesDeserializer(item) {
@@ -449,6 +453,7 @@ export function volumePropertiesDeserializer(item) {
         encryptionKeySource: item["encryptionKeySource"],
         keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
         ldapEnabled: item["ldapEnabled"],
+        ldapServerType: item["ldapServerType"],
         coolAccess: item["coolAccess"],
         coolnessPeriod: item["coolnessPeriod"],
         coolAccessRetrievalPolicy: item["coolAccessRetrievalPolicy"],
@@ -478,8 +483,11 @@ export function volumePropertiesDeserializer(item) {
         enableSubvolumes: item["enableSubvolumes"],
         provisionedAvailabilityZone: item["provisionedAvailabilityZone"],
         isLargeVolume: item["isLargeVolume"],
+        largeVolumeType: item["largeVolumeType"],
         originatingResourceId: item["originatingResourceId"],
         inheritedSizeInBytes: item["inheritedSizeInBytes"],
+        language: item["language"],
+        breakthroughMode: item["breakthroughMode"],
     };
 }
 /** The service level of the file system */
@@ -666,6 +674,10 @@ export function replicationObjectDeserializer(item) {
         destinationReplications: !item["destinationReplications"]
             ? item["destinationReplications"]
             : destinationReplicationArrayDeserializer(item["destinationReplications"]),
+        externalReplicationSetupStatus: item["externalReplicationSetupStatus"],
+        externalReplicationSetupInfo: item["externalReplicationSetupInfo"],
+        mirrorState: item["mirrorState"],
+        relationshipStatus: item["relationshipStatus"],
     };
 }
 /** Indicates whether the local volume is the source or destination for the Volume Replication */
@@ -721,6 +733,38 @@ export var KnownReplicationType;
     /** Cross zone replication */
     KnownReplicationType["CrossZoneReplication"] = "CrossZoneReplication";
 })(KnownReplicationType || (KnownReplicationType = {}));
+/** Property that only applies to external replications. Provides a machine-readable value for the status of the external replication setup. */
+export var KnownExternalReplicationSetupStatus;
+(function (KnownExternalReplicationSetupStatus) {
+    /** Your cluster needs to be peered by using the 'peerExternalCluster' action */
+    KnownExternalReplicationSetupStatus["ClusterPeerRequired"] = "ClusterPeerRequired";
+    /** The peering needs to be accepted on your cluster before the setup can proceed */
+    KnownExternalReplicationSetupStatus["ClusterPeerPending"] = "ClusterPeerPending";
+    /** Need to call 'authorizeExternalReplication' and accept the returned 'vserver peer accept' command on your cluster to finish setting up the external replication */
+    KnownExternalReplicationSetupStatus["VServerPeerRequired"] = "VServerPeerRequired";
+    /** Need to call 'authorizeExternalReplication' to finish setting up the external replication */
+    KnownExternalReplicationSetupStatus["ReplicationCreateRequired"] = "ReplicationCreateRequired";
+    /** External Replication setup is complete, you can now monitor the 'mirrorState' in the replication status for the health of the replication */
+    KnownExternalReplicationSetupStatus["NoActionRequired"] = "NoActionRequired";
+})(KnownExternalReplicationSetupStatus || (KnownExternalReplicationSetupStatus = {}));
+/** The status of the replication */
+export var KnownMirrorState;
+(function (KnownMirrorState) {
+    /** Uninitialized */
+    KnownMirrorState["Uninitialized"] = "Uninitialized";
+    /** Mirrored */
+    KnownMirrorState["Mirrored"] = "Mirrored";
+    /** Broken */
+    KnownMirrorState["Broken"] = "Broken";
+})(KnownMirrorState || (KnownMirrorState = {}));
+/** Status of the volume replication relationship */
+export var KnownVolumeReplicationRelationshipStatus;
+(function (KnownVolumeReplicationRelationshipStatus) {
+    /** Idle */
+    KnownVolumeReplicationRelationshipStatus["Idle"] = "Idle";
+    /** Transferring */
+    KnownVolumeReplicationRelationshipStatus["Transferring"] = "Transferring";
+})(KnownVolumeReplicationRelationshipStatus || (KnownVolumeReplicationRelationshipStatus = {}));
 export function volumeSnapshotPropertiesSerializer(item) {
     return { snapshotPolicyId: item["snapshotPolicyId"] };
 }
@@ -807,6 +851,14 @@ export var KnownEncryptionKeySource;
     /** Customer-managed key encryption */
     KnownEncryptionKeySource["MicrosoftKeyVault"] = "Microsoft.KeyVault";
 })(KnownEncryptionKeySource || (KnownEncryptionKeySource = {}));
+/** The type of the LDAP server */
+export var KnownLdapServerType;
+(function (KnownLdapServerType) {
+    /** The volume should use Active Directory for LDAP connections. */
+    KnownLdapServerType["ActiveDirectory"] = "ActiveDirectory";
+    /** The volume should use OpenLDAP for LDAP connections. */
+    KnownLdapServerType["OpenLdap"] = "OpenLDAP";
+})(KnownLdapServerType || (KnownLdapServerType = {}));
 /**
  * coolAccessRetrievalPolicy determines the data retrieval behavior from the cool tier to standard storage based on the read pattern for cool access enabled volumes. The possible values for this field are:
  * Default - Data will be pulled from cool tier to standard storage on random reads. This policy is the default.
@@ -854,6 +906,172 @@ export var KnownEnableSubvolumes;
     /** subvolumes are not enabled */
     KnownEnableSubvolumes["Disabled"] = "Disabled";
 })(KnownEnableSubvolumes || (KnownEnableSubvolumes = {}));
+/**
+ * Specifies the type of the Large Volume. When set to 'LargeVolume', the large volume is created with standard configuration.
+ * If it is set to 'ExtraLargeVolume7Dot2PiB', the extra large volume is created with higher capacity limit 7.2PiB with cool access enabled,
+ * delivering higher capacity limit with lower costs.
+ */
+export var KnownLargeVolumeType;
+(function (KnownLargeVolumeType) {
+    /** The large volume is created with standard configuration that provides standard performance and throughput. */
+    KnownLargeVolumeType["LargeVolume"] = "LargeVolume";
+    /** The extra large volume is created with higher volume capacity limit 7.2PiB with cool access enabled, delivering higher capacity limit with lower costs */
+    KnownLargeVolumeType["ExtraLargeVolume7Dot2PiB"] = "PremExtraLargeVolume7Dot2PiB";
+})(KnownLargeVolumeType || (KnownLargeVolumeType = {}));
+/** Language supported for volume. */
+export var KnownVolumeLanguage;
+(function (KnownVolumeLanguage) {
+    /** Posix with UTF-8 */
+    KnownVolumeLanguage["CUtf8"] = "c.utf-8";
+    /** UTF-8 with 4 byte character support */
+    KnownVolumeLanguage["Utf8Mb4"] = "utf8mb4";
+    /** Arabic - Deprecated */
+    KnownVolumeLanguage["Ar"] = "ar";
+    /** Arabic with UTF-8 */
+    KnownVolumeLanguage["ArUtf8"] = "ar.utf-8";
+    /** Croatian - Deprecated */
+    KnownVolumeLanguage["Hr"] = "hr";
+    /** Croatian with UTF-8 */
+    KnownVolumeLanguage["HrUtf8"] = "hr.utf-8";
+    /** Czech - Deprecated */
+    KnownVolumeLanguage["Cs"] = "cs";
+    /** Czech with UTF-8 */
+    KnownVolumeLanguage["CsUtf8"] = "cs.utf-8";
+    /** Danish - Deprecated */
+    KnownVolumeLanguage["Da"] = "da";
+    /** Danish with UTF-8 */
+    KnownVolumeLanguage["DaUtf8"] = "da.utf-8";
+    /** Dutch - Deprecated */
+    KnownVolumeLanguage["Nl"] = "nl";
+    /** Dutch with UTF-8 */
+    KnownVolumeLanguage["NlUtf8"] = "nl.utf-8";
+    /** English - Deprecated */
+    KnownVolumeLanguage["En"] = "en";
+    /** English with UTF-8 */
+    KnownVolumeLanguage["EnUtf8"] = "en.utf-8";
+    /** Finnish - Deprecated */
+    KnownVolumeLanguage["Fi"] = "fi";
+    /** Finnish with UTF-8 */
+    KnownVolumeLanguage["FiUtf8"] = "fi.utf-8";
+    /** French - Deprecated */
+    KnownVolumeLanguage["Fr"] = "fr";
+    /** French with UTF-8 */
+    KnownVolumeLanguage["FrUtf8"] = "fr.utf-8";
+    /** German - Deprecated */
+    KnownVolumeLanguage["De"] = "de";
+    /** German with UTF-8 */
+    KnownVolumeLanguage["DeUtf8"] = "de.utf-8";
+    /** Hebrew - Deprecated */
+    KnownVolumeLanguage["He"] = "he";
+    /** Hebrew with UTF-8 */
+    KnownVolumeLanguage["HeUtf8"] = "he.utf-8";
+    /** Hungarian - Deprecated */
+    KnownVolumeLanguage["Hu"] = "hu";
+    /** Hungarian with UTF-8 */
+    KnownVolumeLanguage["HuUtf8"] = "hu.utf-8";
+    /** Italian - Deprecated */
+    KnownVolumeLanguage["It"] = "it";
+    /** Italian with UTF-8 */
+    KnownVolumeLanguage["ItUtf8"] = "it.utf-8";
+    /** Japanese euc-j - Deprecated */
+    KnownVolumeLanguage["Ja"] = "ja";
+    /** Japanese euc-j with UTF-8 */
+    KnownVolumeLanguage["JaUtf8"] = "ja.utf-8";
+    /** Japanese euc-j - Deprecated */
+    KnownVolumeLanguage["JaV1"] = "ja-v1";
+    /** Japanese euc-j with UTF-8 */
+    KnownVolumeLanguage["JaV1Utf8"] = "ja-v1.utf-8";
+    /** Japanese pck */
+    KnownVolumeLanguage["JaJpPck"] = "ja-jp.pck";
+    /** Japanese pck with UTF-8 - Deprecated */
+    KnownVolumeLanguage["JaJpPckUtf8"] = "ja-jp.pck.utf-8";
+    /** Japanese cp932 */
+    KnownVolumeLanguage["JaJp932"] = "ja-jp.932";
+    /** Japanese cp932 with UTF-8 - Deprecated */
+    KnownVolumeLanguage["JaJp932Utf8"] = "ja-jp.932.utf-8";
+    /** Japanese pck - sjis */
+    KnownVolumeLanguage["JaJpPckV2"] = "ja-jp.pck-v2";
+    /** Japanese pck - sjis with UTF-8 - Deprecated */
+    KnownVolumeLanguage["JaJpPckV2Utf8"] = "ja-jp.pck-v2.utf-8";
+    /** Korean - Deprecated */
+    KnownVolumeLanguage["Ko"] = "ko";
+    /** Korean with UTF-8 */
+    KnownVolumeLanguage["KoUtf8"] = "ko.utf-8";
+    /** Norwegian - Deprecated */
+    KnownVolumeLanguage["No"] = "no";
+    /** Norwegian with UTF-8 */
+    KnownVolumeLanguage["NoUtf8"] = "no.utf-8";
+    /** Polish - Deprecated */
+    KnownVolumeLanguage["Pl"] = "pl";
+    /** Polish with UTF-8 */
+    KnownVolumeLanguage["PlUtf8"] = "pl.utf-8";
+    /** Portuguese - Deprecated */
+    KnownVolumeLanguage["Pt"] = "pt";
+    /** Portuguese with UTF-8 */
+    KnownVolumeLanguage["PtUtf8"] = "pt.utf-8";
+    /** Posix - Deprecated */
+    KnownVolumeLanguage["C"] = "c";
+    /** Romanian - Deprecated */
+    KnownVolumeLanguage["Ro"] = "ro";
+    /** Romanian with UTF-8 */
+    KnownVolumeLanguage["RoUtf8"] = "ro.utf-8";
+    /** Russian - Deprecated */
+    KnownVolumeLanguage["Ru"] = "ru";
+    /** Russian with UTF-8 */
+    KnownVolumeLanguage["RuUtf8"] = "ru.utf-8";
+    /** Simplified Chinese - Deprecated */
+    KnownVolumeLanguage["Zh"] = "zh";
+    /** Simplified Chinese with UTF-8 */
+    KnownVolumeLanguage["ZhUtf8"] = "zh.utf-8";
+    /** Simplified gbk Chinese */
+    KnownVolumeLanguage["ZhGbk"] = "zh.gbk";
+    /** Simplified gbk Chinese with UTF-8 - Deprecated */
+    KnownVolumeLanguage["ZhGbkUtf8"] = "zh.gbk.utf-8";
+    /** Traditional Chinese BIG 5 */
+    KnownVolumeLanguage["ZhTwBig5"] = "zh-tw.big5";
+    /** Traditional Chinese BIG 5 with UTF-8 - Deprecated */
+    KnownVolumeLanguage["ZhTwBig5Utf8"] = "zh-tw.big5.utf-8";
+    /** Traditional Chinese EUC-TW */
+    KnownVolumeLanguage["ZhTw"] = "zh-tw";
+    /** Traditional Chinese EUC-TW with UTF-8 - Deprecated */
+    KnownVolumeLanguage["ZhTwUtf8"] = "zh-tw.utf-8";
+    /** Slovak - Deprecated */
+    KnownVolumeLanguage["Sk"] = "sk";
+    /** Slovak with UTF-8 */
+    KnownVolumeLanguage["SkUtf8"] = "sk.utf-8";
+    /** Slovenian - Deprecated */
+    KnownVolumeLanguage["Sl"] = "sl";
+    /** Slovenian with UTF-8 */
+    KnownVolumeLanguage["SlUtf8"] = "sl.utf-8";
+    /** Spanish - Deprecated */
+    KnownVolumeLanguage["Es"] = "es";
+    /** Spanish with UTF-8 */
+    KnownVolumeLanguage["EsUtf8"] = "es.utf-8";
+    /** Swedish - Deprecated */
+    KnownVolumeLanguage["Sv"] = "sv";
+    /** Swedish with UTF-8 */
+    KnownVolumeLanguage["SvUtf8"] = "sv.utf-8";
+    /** Turkish - Deprecated */
+    KnownVolumeLanguage["Tr"] = "tr";
+    /** Turkish with UTF-8 */
+    KnownVolumeLanguage["TrUtf8"] = "tr.utf-8";
+    /** US English - Deprecated */
+    KnownVolumeLanguage["EnUs"] = "en-us";
+    /** US English with UTF-8 */
+    KnownVolumeLanguage["EnUsUtf8"] = "en-us.utf-8";
+})(KnownVolumeLanguage || (KnownVolumeLanguage = {}));
+/**
+ * Specifies whether the volume operates in Breakthrough Mode. When set to 'Enabled', the volume runs on the resources configured for this mode,
+ * delivering improved performance and higher throughput. If set to 'Disabled' or omitted, the volume uses the basic configuration. This feature
+ * is available only in regions where it’s been configured and first-time users must finish onboarding prior to using Breakthrough Mode.
+ */
+export var KnownBreakthroughMode;
+(function (KnownBreakthroughMode) {
+    /** The volume runs on the resources configured for Breakthrough mode which ensures consistent high performance and a higher throughput. */
+    KnownBreakthroughMode["Enabled"] = "Enabled";
+    /** The volume uses configuration that provides basic performance and throughput. */
+    KnownBreakthroughMode["Disabled"] = "Disabled";
+})(KnownBreakthroughMode || (KnownBreakthroughMode = {}));
 export function _volumeGroupListDeserializer(item) {
     return {
         value: volumeGroupArrayDeserializer(item["value"]),
@@ -987,16 +1205,6 @@ export var KnownVolumeBackupRelationshipStatus;
     /** Unknown */
     KnownVolumeBackupRelationshipStatus["Unknown"] = "Unknown";
 })(KnownVolumeBackupRelationshipStatus || (KnownVolumeBackupRelationshipStatus = {}));
-/** The status of the replication */
-export var KnownMirrorState;
-(function (KnownMirrorState) {
-    /** Uninitialized */
-    KnownMirrorState["Uninitialized"] = "Uninitialized";
-    /** Mirrored */
-    KnownMirrorState["Mirrored"] = "Mirrored";
-    /** Broken */
-    KnownMirrorState["Broken"] = "Broken";
-})(KnownMirrorState || (KnownMirrorState = {}));
 export function restoreStatusDeserializer(item) {
     return {
         healthy: item["healthy"],
@@ -1176,14 +1384,6 @@ export function replicationStatusDeserializer(item) {
         errorMessage: item["errorMessage"],
     };
 }
-/** Status of the volume replication relationship */
-export var KnownVolumeReplicationRelationshipStatus;
-(function (KnownVolumeReplicationRelationshipStatus) {
-    /** Idle */
-    KnownVolumeReplicationRelationshipStatus["Idle"] = "Idle";
-    /** Transferring */
-    KnownVolumeReplicationRelationshipStatus["Transferring"] = "Transferring";
-})(KnownVolumeReplicationRelationshipStatus || (KnownVolumeReplicationRelationshipStatus = {}));
 export function listReplicationsRequestSerializer(item) {
     return { exclude: item["exclude"] };
 }
@@ -1840,7 +2040,14 @@ export function backupVaultArrayDeserializer(result) {
         return backupVaultDeserializer(item);
     });
 }
-export function regionInfoResourceDeserializer(item) {
+export function bucketSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : bucketPropertiesSerializer(item["properties"]),
+    };
+}
+export function bucketDeserializer(item) {
     return {
         id: item["id"],
         name: item["name"],
@@ -1850,72 +2057,237 @@ export function regionInfoResourceDeserializer(item) {
             : systemDataDeserializer(item["systemData"]),
         properties: !item["properties"]
             ? item["properties"]
-            : regionInfoDeserializer(item["properties"]),
+            : bucketPropertiesDeserializer(item["properties"]),
     };
 }
-export function regionInfoDeserializer(item) {
+export function bucketPropertiesSerializer(item) {
     return {
-        storageToNetworkProximity: item["storageToNetworkProximity"],
-        availabilityZoneMappings: !item["availabilityZoneMappings"]
-            ? item["availabilityZoneMappings"]
-            : regionInfoAvailabilityZoneMappingsItemArrayDeserializer(item["availabilityZoneMappings"]),
+        path: item["path"],
+        fileSystemUser: !item["fileSystemUser"]
+            ? item["fileSystemUser"]
+            : fileSystemUserSerializer(item["fileSystemUser"]),
+        server: !item["server"] ? item["server"] : bucketServerPropertiesSerializer(item["server"]),
+        permissions: item["permissions"],
+        akvDetails: !item["akvDetails"]
+            ? item["akvDetails"]
+            : azureKeyVaultDetailsSerializer(item["akvDetails"]),
     };
 }
-/** Provides storage to network proximity information in the region. */
-export var KnownRegionStorageToNetworkProximity;
-(function (KnownRegionStorageToNetworkProximity) {
-    /** Basic network connectivity. */
-    KnownRegionStorageToNetworkProximity["Default"] = "Default";
-    /** Standard T1 network connectivity. */
-    KnownRegionStorageToNetworkProximity["T1"] = "T1";
-    /** Standard T2 network connectivity. */
-    KnownRegionStorageToNetworkProximity["T2"] = "T2";
-    /** Standard AcrossT2 network connectivity. */
-    KnownRegionStorageToNetworkProximity["AcrossT2"] = "AcrossT2";
-    /** Standard T1 and T2 network connectivity. */
-    KnownRegionStorageToNetworkProximity["T1AndT2"] = "T1AndT2";
-    /** Standard T1 and AcrossT2 network connectivity. */
-    KnownRegionStorageToNetworkProximity["T1AndAcrossT2"] = "T1AndAcrossT2";
-    /** Standard T2 and AcrossT2 network connectivity. */
-    KnownRegionStorageToNetworkProximity["T2AndAcrossT2"] = "T2AndAcrossT2";
-    /** Standard T1, T2 and AcrossT2 network connectivity. */
-    KnownRegionStorageToNetworkProximity["T1AndT2AndAcrossT2"] = "T1AndT2AndAcrossT2";
-})(KnownRegionStorageToNetworkProximity || (KnownRegionStorageToNetworkProximity = {}));
-export function regionInfoAvailabilityZoneMappingsItemArrayDeserializer(result) {
-    return result.map((item) => {
-        return regionInfoAvailabilityZoneMappingsItemDeserializer(item);
-    });
+export function bucketPropertiesDeserializer(item) {
+    return {
+        path: item["path"],
+        fileSystemUser: !item["fileSystemUser"]
+            ? item["fileSystemUser"]
+            : fileSystemUserDeserializer(item["fileSystemUser"]),
+        provisioningState: item["provisioningState"],
+        status: item["status"],
+        server: !item["server"] ? item["server"] : bucketServerPropertiesDeserializer(item["server"]),
+        permissions: item["permissions"],
+        akvDetails: !item["akvDetails"]
+            ? item["akvDetails"]
+            : azureKeyVaultDetailsDeserializer(item["akvDetails"]),
+    };
 }
-export function regionInfoAvailabilityZoneMappingsItemDeserializer(item) {
+export function fileSystemUserSerializer(item) {
     return {
-        availabilityZone: item["availabilityZone"],
-        isAvailable: item["isAvailable"],
+        nfsUser: !item["nfsUser"] ? item["nfsUser"] : nfsUserSerializer(item["nfsUser"]),
+        cifsUser: !item["cifsUser"] ? item["cifsUser"] : cifsUserSerializer(item["cifsUser"]),
     };
 }
-export function _regionInfosListDeserializer(item) {
+export function fileSystemUserDeserializer(item) {
     return {
-        value: regionInfoResourceArrayDeserializer(item["value"]),
+        nfsUser: !item["nfsUser"] ? item["nfsUser"] : nfsUserDeserializer(item["nfsUser"]),
+        cifsUser: !item["cifsUser"] ? item["cifsUser"] : cifsUserDeserializer(item["cifsUser"]),
+    };
+}
+export function nfsUserSerializer(item) {
+    return { userId: item["userId"], groupId: item["groupId"] };
+}
+export function nfsUserDeserializer(item) {
+    return {
+        userId: item["userId"],
+        groupId: item["groupId"],
+    };
+}
+export function cifsUserSerializer(item) {
+    return { username: item["username"] };
+}
+export function cifsUserDeserializer(item) {
+    return {
+        username: item["username"],
+    };
+}
+/**
+ * The bucket credentials status. There states:
+ *
+ * "NoCredentialsSet": Access and Secret key pair have not been generated.
+ * "CredentialsExpired": Access and Secret key pair have expired.
+ * "Active": The certificate has been installed and credentials are unexpired.
+ */
+export var KnownCredentialsStatus;
+(function (KnownCredentialsStatus) {
+    /** Access and Secret key pair have not been generated. */
+    KnownCredentialsStatus["NoCredentialsSet"] = "NoCredentialsSet";
+    /** Access and Secret key pair have expired. */
+    KnownCredentialsStatus["CredentialsExpired"] = "CredentialsExpired";
+    /** The certificate has been installed on the bucket server and the bucket credentials are unexpired. */
+    KnownCredentialsStatus["Active"] = "Active";
+})(KnownCredentialsStatus || (KnownCredentialsStatus = {}));
+export function bucketServerPropertiesSerializer(item) {
+    return {
+        fqdn: item["fqdn"],
+        certificateObject: item["certificateObject"],
+        onCertificateConflictAction: item["onCertificateConflictAction"],
+    };
+}
+export function bucketServerPropertiesDeserializer(item) {
+    return {
+        fqdn: item["fqdn"],
+        certificateCommonName: item["certificateCommonName"],
+        certificateExpiryDate: !item["certificateExpiryDate"]
+            ? item["certificateExpiryDate"]
+            : new Date(item["certificateExpiryDate"]),
+        ipAddress: item["ipAddress"],
+        certificateObject: item["certificateObject"],
+        onCertificateConflictAction: item["onCertificateConflictAction"],
+    };
+}
+/**
+ * This action is triggered when a certificate conflict occurs. A conflict arises if you try to create a new bucket while one or more already exist on the server, or if you update a bucket when multiple buckets are present. This happens because a single certificate is shared among all buckets on the same server.
+ *
+ * Note: This applies both to certificates provided directly via the certificateObject property and to those retrieved from Azure Key Vault. Details for the latter case are specified in the akvDetails.certificateAkvDetails section.
+ */
+export var KnownOnCertificateConflictAction;
+(function (KnownOnCertificateConflictAction) {
+    /** Update the existing certificate regardless of whether there is a conflict or not. This means all buckets on the server will now use the new certificate. */
+    KnownOnCertificateConflictAction["Update"] = "Update";
+    /** Fail the operation if a conflict occurs, meaning the bucket operation will fail, and the existing certificate will continue to be in use. */
+    KnownOnCertificateConflictAction["Fail"] = "Fail";
+})(KnownOnCertificateConflictAction || (KnownOnCertificateConflictAction = {}));
+/** Access permissions for the bucket. Either ReadOnly or ReadWrite. The default is ReadOnly if no value is provided during bucket creation. */
+export var KnownBucketPermissions;
+(function (KnownBucketPermissions) {
+    /** Read-only access to bucket. */
+    KnownBucketPermissions["ReadOnly"] = "ReadOnly";
+    /** Read-write access to bucket. */
+    KnownBucketPermissions["ReadWrite"] = "ReadWrite";
+})(KnownBucketPermissions || (KnownBucketPermissions = {}));
+export function azureKeyVaultDetailsSerializer(item) {
+    return {
+        certificateAkvDetails: !item["certificateAkvDetails"]
+            ? item["certificateAkvDetails"]
+            : certificateAkvDetailsSerializer(item["certificateAkvDetails"]),
+        credentialsAkvDetails: !item["credentialsAkvDetails"]
+            ? item["credentialsAkvDetails"]
+            : credentialsAkvDetailsSerializer(item["credentialsAkvDetails"]),
+    };
+}
+export function azureKeyVaultDetailsDeserializer(item) {
+    return {
+        certificateAkvDetails: !item["certificateAkvDetails"]
+            ? item["certificateAkvDetails"]
+            : certificateAkvDetailsDeserializer(item["certificateAkvDetails"]),
+        credentialsAkvDetails: !item["credentialsAkvDetails"]
+            ? item["credentialsAkvDetails"]
+            : credentialsAkvDetailsDeserializer(item["credentialsAkvDetails"]),
+    };
+}
+export function certificateAkvDetailsSerializer(item) {
+    return {
+        certificateKeyVaultUri: item["certificateKeyVaultUri"],
+        certificateName: item["certificateName"],
+    };
+}
+export function certificateAkvDetailsDeserializer(item) {
+    return {
+        certificateKeyVaultUri: item["certificateKeyVaultUri"],
+        certificateName: item["certificateName"],
+    };
+}
+export function credentialsAkvDetailsSerializer(item) {
+    return { credentialsKeyVaultUri: item["credentialsKeyVaultUri"], secretName: item["secretName"] };
+}
+export function credentialsAkvDetailsDeserializer(item) {
+    return {
+        credentialsKeyVaultUri: item["credentialsKeyVaultUri"],
+        secretName: item["secretName"],
+    };
+}
+export function bucketPatchSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : bucketPatchPropertiesSerializer(item["properties"]),
+    };
+}
+export function bucketPatchPropertiesSerializer(item) {
+    return {
+        fileSystemUser: !item["fileSystemUser"]
+            ? item["fileSystemUser"]
+            : fileSystemUserSerializer(item["fileSystemUser"]),
+        server: !item["server"]
+            ? item["server"]
+            : bucketServerPatchPropertiesSerializer(item["server"]),
+        permissions: item["permissions"],
+        akvDetails: !item["akvDetails"]
+            ? item["akvDetails"]
+            : azureKeyVaultDetailsSerializer(item["akvDetails"]),
+    };
+}
+export function bucketServerPatchPropertiesSerializer(item) {
+    return {
+        fqdn: item["fqdn"],
+        certificateObject: item["certificateObject"],
+        onCertificateConflictAction: item["onCertificateConflictAction"],
+    };
+}
+/** Access permissions for the bucket. Either ReadOnly or ReadWrite. */
+export var KnownBucketPatchPermissions;
+(function (KnownBucketPatchPermissions) {
+    /** Read-only access to bucket. */
+    KnownBucketPatchPermissions["ReadOnly"] = "ReadOnly";
+    /** Read-write access to bucket. */
+    KnownBucketPatchPermissions["ReadWrite"] = "ReadWrite";
+})(KnownBucketPatchPermissions || (KnownBucketPatchPermissions = {}));
+export function _bucketListDeserializer(item) {
+    return {
+        value: bucketArrayDeserializer(item["value"]),
         nextLink: item["nextLink"],
     };
 }
-export function regionInfoResourceArrayDeserializer(result) {
+export function bucketArraySerializer(result) {
     return result.map((item) => {
-        return regionInfoResourceDeserializer(item);
+        return bucketSerializer(item);
     });
 }
-export function netAppAccountSerializer(item) {
+export function bucketArrayDeserializer(result) {
+    return result.map((item) => {
+        return bucketDeserializer(item);
+    });
+}
+export function bucketCredentialsExpirySerializer(item) {
+    return { keyPairExpiryDays: item["keyPairExpiryDays"] };
+}
+export function bucketGenerateCredentialsDeserializer(item) {
+    return {
+        accessKey: item["accessKey"],
+        secretKey: item["secretKey"],
+        keyPairExpiry: !item["keyPairExpiry"] ? item["keyPairExpiry"] : new Date(item["keyPairExpiry"]),
+    };
+}
+export function cacheSerializer(item) {
     return {
         tags: item["tags"],
         location: item["location"],
-        properties: !item["properties"]
-            ? item["properties"]
-            : accountPropertiesSerializer(item["properties"]),
-        identity: !item["identity"]
-            ? item["identity"]
-            : managedServiceIdentitySerializer(item["identity"]),
+        properties: cachePropertiesSerializer(item["properties"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
     };
 }
-export function netAppAccountDeserializer(item) {
+export function cacheDeserializer(item) {
     return {
         tags: !item["tags"]
             ? item["tags"]
@@ -1927,80 +2299,1814 @@ export function netAppAccountDeserializer(item) {
         systemData: !item["systemData"]
             ? item["systemData"]
             : systemDataDeserializer(item["systemData"]),
-        properties: !item["properties"]
-            ? item["properties"]
-            : accountPropertiesDeserializer(item["properties"]),
+        properties: cachePropertiesDeserializer(item["properties"]),
         etag: item["etag"],
-        identity: !item["identity"]
-            ? item["identity"]
-            : managedServiceIdentityDeserializer(item["identity"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
     };
 }
-export function accountPropertiesSerializer(item) {
+export function cachePropertiesSerializer(item) {
     return {
-        activeDirectories: !item["activeDirectories"]
-            ? item["activeDirectories"]
-            : activeDirectoryArraySerializer(item["activeDirectories"]),
-        encryption: !item["encryption"]
-            ? item["encryption"]
-            : accountEncryptionSerializer(item["encryption"]),
-        nfsV4IDDomain: item["nfsV4IDDomain"],
+        filePath: item["filePath"],
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : cachePropertiesExportPolicySerializer(item["exportPolicy"]),
+        protocolTypes: !item["protocolTypes"]
+            ? item["protocolTypes"]
+            : item["protocolTypes"].map((p) => {
+                return p;
+            }),
+        cacheSubnetResourceId: item["cacheSubnetResourceId"],
+        peeringSubnetResourceId: item["peeringSubnetResourceId"],
+        kerberos: item["kerberos"],
+        smbSettings: !item["smbSettings"]
+            ? item["smbSettings"]
+            : smbSettingsSerializer(item["smbSettings"]),
+        throughputMibps: item["throughputMibps"],
+        encryptionKeySource: item["encryptionKeySource"],
+        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
+        ldap: item["ldap"],
+        ldapServerType: item["ldapServerType"],
+        originClusterInformation: originClusterInformationSerializer(item["originClusterInformation"]),
+        cifsChangeNotifications: item["cifsChangeNotifications"],
+        globalFileLocking: item["globalFileLocking"],
+        writeBack: item["writeBack"],
     };
 }
-export function accountPropertiesDeserializer(item) {
+export function cachePropertiesDeserializer(item) {
     return {
+        filePath: item["filePath"],
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : cachePropertiesExportPolicyDeserializer(item["exportPolicy"]),
+        protocolTypes: !item["protocolTypes"]
+            ? item["protocolTypes"]
+            : item["protocolTypes"].map((p) => {
+                return p;
+            }),
         provisioningState: item["provisioningState"],
-        activeDirectories: !item["activeDirectories"]
-            ? item["activeDirectories"]
-            : activeDirectoryArrayDeserializer(item["activeDirectories"]),
-        encryption: !item["encryption"]
-            ? item["encryption"]
-            : accountEncryptionDeserializer(item["encryption"]),
-        disableShowmount: item["disableShowmount"],
-        nfsV4IDDomain: item["nfsV4IDDomain"],
-        multiAdStatus: item["multiAdStatus"],
+        cacheState: item["cacheState"],
+        cacheSubnetResourceId: item["cacheSubnetResourceId"],
+        peeringSubnetResourceId: item["peeringSubnetResourceId"],
+        mountTargets: !item["mountTargets"]
+            ? item["mountTargets"]
+            : cacheMountTargetPropertiesArrayDeserializer(item["mountTargets"]),
+        kerberos: item["kerberos"],
+        smbSettings: !item["smbSettings"]
+            ? item["smbSettings"]
+            : smbSettingsDeserializer(item["smbSettings"]),
+        throughputMibps: item["throughputMibps"],
+        actualThroughputMibps: item["actualThroughputMibps"],
+        encryptionKeySource: item["encryptionKeySource"],
+        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
+        maximumNumberOfFiles: item["maximumNumberOfFiles"],
+        encryption: item["encryption"],
+        language: item["language"],
+        ldap: item["ldap"],
+        ldapServerType: item["ldapServerType"],
+        originClusterInformation: originClusterInformationDeserializer(item["originClusterInformation"]),
+        cifsChangeNotifications: item["cifsChangeNotifications"],
+        globalFileLocking: item["globalFileLocking"],
+        writeBack: item["writeBack"],
     };
 }
-export function activeDirectoryArraySerializer(result) {
-    return result.map((item) => {
-        return activeDirectorySerializer(item);
-    });
+export function cachePropertiesExportPolicySerializer(item) {
+    return { rules: !item["rules"] ? item["rules"] : exportPolicyRuleArraySerializer(item["rules"]) };
 }
-export function activeDirectoryArrayDeserializer(result) {
+export function cachePropertiesExportPolicyDeserializer(item) {
+    return {
+        rules: !item["rules"] ? item["rules"] : exportPolicyRuleArrayDeserializer(item["rules"]),
+    };
+}
+/** Set of supported protocol types, which include NFSv3, NFSv4 and SMB protocol */
+export var KnownProtocolTypes;
+(function (KnownProtocolTypes) {
+    /** NFSv3 protocol type */
+    KnownProtocolTypes["NFSv3"] = "NFSv3";
+    /** NFSv4 protocol type */
+    KnownProtocolTypes["NFSv4"] = "NFSv4";
+    /** SMB protocol type */
+    KnownProtocolTypes["SMB"] = "SMB";
+})(KnownProtocolTypes || (KnownProtocolTypes = {}));
+/** Azure lifecycle management */
+export var KnownCacheProvisioningState;
+(function (KnownCacheProvisioningState) {
+    /** The resource is being created. */
+    KnownCacheProvisioningState["Creating"] = "Creating";
+    /** The resource is being updated. */
+    KnownCacheProvisioningState["Updating"] = "Updating";
+    /** The resource is being deleted. */
+    KnownCacheProvisioningState["Deleting"] = "Deleting";
+    /** The resource is in a failed state. */
+    KnownCacheProvisioningState["Failed"] = "Failed";
+    /** The resource is succeeded. */
+    KnownCacheProvisioningState["Succeeded"] = "Succeeded";
+    /** Resource creation was canceled. */
+    KnownCacheProvisioningState["Canceled"] = "Canceled";
+})(KnownCacheProvisioningState || (KnownCacheProvisioningState = {}));
+/** Azure NetApp Files Cache lifecycle management */
+export var KnownCacheLifeCycleState;
+(function (KnownCacheLifeCycleState) {
+    /** Cluster peering offer has been sent. */
+    KnownCacheLifeCycleState["ClusterPeeringOfferSent"] = "ClusterPeeringOfferSent";
+    /** VServer peering offer has been sent. */
+    KnownCacheLifeCycleState["VserverPeeringOfferSent"] = "VserverPeeringOfferSent";
+    /** Cache creation in progress. */
+    KnownCacheLifeCycleState["Creating"] = "Creating";
+    /** Cache creation succeeded and is available for use. */
+    KnownCacheLifeCycleState["Succeeded"] = "Succeeded";
+    /** Cache is in a failed state */
+    KnownCacheLifeCycleState["Failed"] = "Failed";
+})(KnownCacheLifeCycleState || (KnownCacheLifeCycleState = {}));
+export function cacheMountTargetPropertiesArrayDeserializer(result) {
     return result.map((item) => {
-        return activeDirectoryDeserializer(item);
+        return cacheMountTargetPropertiesDeserializer(item);
     });
 }
-export function activeDirectorySerializer(item) {
+export function cacheMountTargetPropertiesDeserializer(item) {
     return {
-        activeDirectoryId: item["activeDirectoryId"],
-        username: item["username"],
-        password: item["password"],
-        domain: item["domain"],
-        dns: item["dns"],
-        smbServerName: item["smbServerName"],
-        organizationalUnit: item["organizationalUnit"],
-        site: item["site"],
-        backupOperators: !item["backupOperators"]
-            ? item["backupOperators"]
-            : item["backupOperators"].map((p) => {
-                return p;
-            }),
-        administrators: !item["administrators"]
-            ? item["administrators"]
-            : item["administrators"].map((p) => {
-                return p;
-            }),
-        kdcIP: item["kdcIP"],
-        adName: item["adName"],
-        serverRootCACertificate: item["serverRootCACertificate"],
-        aesEncryption: item["aesEncryption"],
-        ldapSigning: item["ldapSigning"],
-        securityOperators: !item["securityOperators"]
-            ? item["securityOperators"]
-            : item["securityOperators"].map((p) => {
-                return p;
-            }),
+        mountTargetId: item["mountTargetId"],
+        ipAddress: item["ipAddress"],
+        smbServerFqdn: item["smbServerFqdn"],
+    };
+}
+/** Describe if a cache is Kerberos enabled. */
+export var KnownKerberosState;
+(function (KnownKerberosState) {
+    /** Kerberos is disabled */
+    KnownKerberosState["Disabled"] = "Disabled";
+    /** Kerberos is enabled */
+    KnownKerberosState["Enabled"] = "Enabled";
+})(KnownKerberosState || (KnownKerberosState = {}));
+export function smbSettingsSerializer(item) {
+    return {
+        smbEncryption: item["smbEncryption"],
+        smbAccessBasedEnumeration: item["smbAccessBasedEnumeration"],
+        smbNonBrowsable: item["smbNonBrowsable"],
+    };
+}
+export function smbSettingsDeserializer(item) {
+    return {
+        smbEncryption: item["smbEncryption"],
+        smbAccessBasedEnumeration: item["smbAccessBasedEnumeration"],
+        smbNonBrowsable: item["smbNonBrowsable"],
+    };
+}
+/** Enables encryption for in-flight smb3 data. Only applicable for SMB/DualProtocol cache */
+export var KnownSmbEncryptionState;
+(function (KnownSmbEncryptionState) {
+    /** SMB encryption is disabled */
+    KnownSmbEncryptionState["Disabled"] = "Disabled";
+    /** SMB encryption is enabled */
+    KnownSmbEncryptionState["Enabled"] = "Enabled";
+})(KnownSmbEncryptionState || (KnownSmbEncryptionState = {}));
+/** Specifies if the cache is encryption or not. */
+export var KnownEncryptionState;
+(function (KnownEncryptionState) {
+    /** Encryption is disabled */
+    KnownEncryptionState["Disabled"] = "Disabled";
+    /** Encryption is enabled */
+    KnownEncryptionState["Enabled"] = "Enabled";
+})(KnownEncryptionState || (KnownEncryptionState = {}));
+/** Specifies whether LDAP is enabled or not. */
+export var KnownLdapState;
+(function (KnownLdapState) {
+    /** ldap is disabled. */
+    KnownLdapState["Disabled"] = "Disabled";
+    /** ldap is enabled */
+    KnownLdapState["Enabled"] = "Enabled";
+})(KnownLdapState || (KnownLdapState = {}));
+export function originClusterInformationSerializer(item) {
+    return {
+        peerClusterName: item["peerClusterName"],
+        peerAddresses: item["peerAddresses"].map((p) => {
+            return p;
+        }),
+        peerVserverName: item["peerVserverName"],
+        peerVolumeName: item["peerVolumeName"],
+    };
+}
+export function originClusterInformationDeserializer(item) {
+    return {
+        peerClusterName: item["peerClusterName"],
+        peerAddresses: item["peerAddresses"].map((p) => {
+            return p;
+        }),
+        peerVserverName: item["peerVserverName"],
+        peerVolumeName: item["peerVolumeName"],
+    };
+}
+/** Flag indicating whether a CIFS change notification is enabled for the cache. */
+export var KnownCifsChangeNotifyState;
+(function (KnownCifsChangeNotifyState) {
+    /** CIFS change notification is disabled */
+    KnownCifsChangeNotifyState["Disabled"] = "Disabled";
+    /** CIFS change notification is enabled */
+    KnownCifsChangeNotifyState["Enabled"] = "Enabled";
+})(KnownCifsChangeNotifyState || (KnownCifsChangeNotifyState = {}));
+/** Flag indicating whether the global file lock is enabled for the cache. */
+export var KnownGlobalFileLockingState;
+(function (KnownGlobalFileLockingState) {
+    /** Global file locking is disabled */
+    KnownGlobalFileLockingState["Disabled"] = "Disabled";
+    /** Global file locking is enabled */
+    KnownGlobalFileLockingState["Enabled"] = "Enabled";
+})(KnownGlobalFileLockingState || (KnownGlobalFileLockingState = {}));
+/** Flag indicating whether writeback is enabled for the cache. */
+export var KnownEnableWriteBackState;
+(function (KnownEnableWriteBackState) {
+    /** Writeback cache is disabled */
+    KnownEnableWriteBackState["Disabled"] = "Disabled";
+    /** Writeback cache is enabled */
+    KnownEnableWriteBackState["Enabled"] = "Enabled";
+})(KnownEnableWriteBackState || (KnownEnableWriteBackState = {}));
+export function cacheUpdateSerializer(item) {
+    return {
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : cacheUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function cacheUpdatePropertiesSerializer(item) {
+    return {
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : cachePropertiesExportPolicySerializer(item["exportPolicy"]),
+        protocolTypes: !item["protocolTypes"]
+            ? item["protocolTypes"]
+            : item["protocolTypes"].map((p) => {
+                return p;
+            }),
+        smbSettings: !item["smbSettings"]
+            ? item["smbSettings"]
+            : smbSettingsSerializer(item["smbSettings"]),
+        throughputMibps: item["throughputMibps"],
+        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
+        cifsChangeNotifications: item["cifsChangeNotifications"],
+        writeBack: item["writeBack"],
+    };
+}
+export function _cacheListDeserializer(item) {
+    return {
+        value: cacheArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function cacheArraySerializer(result) {
+    return result.map((item) => {
+        return cacheSerializer(item);
+    });
+}
+export function cacheArrayDeserializer(result) {
+    return result.map((item) => {
+        return cacheDeserializer(item);
+    });
+}
+export function peeringPassphrasesDeserializer(item) {
+    return {
+        clusterPeeringCommand: item["clusterPeeringCommand"],
+        clusterPeeringPassphrase: item["clusterPeeringPassphrase"],
+        vserverPeeringCommand: item["vserverPeeringCommand"],
+        criticalWarning: item["criticalWarning"],
+    };
+}
+export function elasticAccountSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticAccountPropertiesSerializer(item["properties"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentitySerializer(item["identity"]),
+    };
+}
+export function elasticAccountDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticAccountPropertiesDeserializer(item["properties"]),
+        eTag: item["eTag"],
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentityDeserializer(item["identity"]),
+    };
+}
+export function elasticAccountPropertiesSerializer(item) {
+    return {
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : elasticEncryptionSerializer(item["encryption"]),
+    };
+}
+export function elasticAccountPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : elasticEncryptionDeserializer(item["encryption"]),
+    };
+}
+export function elasticEncryptionSerializer(item) {
+    return {
+        keySource: item["keySource"],
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : elasticKeyVaultPropertiesSerializer(item["keyVaultProperties"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : elasticEncryptionIdentitySerializer(item["identity"]),
+    };
+}
+export function elasticEncryptionDeserializer(item) {
+    return {
+        keySource: item["keySource"],
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : elasticKeyVaultPropertiesDeserializer(item["keyVaultProperties"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : elasticEncryptionIdentityDeserializer(item["identity"]),
+    };
+}
+/** The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.NetApp, Microsoft.KeyVault */
+export var KnownKeySource;
+(function (KnownKeySource) {
+    /** Microsoft-managed key encryption */
+    KnownKeySource["MicrosoftNetApp"] = "Microsoft.NetApp";
+    /** Customer-managed key encryption */
+    KnownKeySource["MicrosoftKeyVault"] = "Microsoft.KeyVault";
+})(KnownKeySource || (KnownKeySource = {}));
+export function elasticKeyVaultPropertiesSerializer(item) {
+    return {
+        keyVaultUri: item["keyVaultUri"],
+        keyName: item["keyName"],
+        keyVaultResourceId: item["keyVaultResourceId"],
+    };
+}
+export function elasticKeyVaultPropertiesDeserializer(item) {
+    return {
+        keyVaultUri: item["keyVaultUri"],
+        keyName: item["keyName"],
+        keyVaultResourceId: item["keyVaultResourceId"],
+        status: item["status"],
+    };
+}
+/** KeyVault status */
+export var KnownElasticKeyVaultStatus;
+(function (KnownElasticKeyVaultStatus) {
+    /** KeyVault connection created but not in use */
+    KnownElasticKeyVaultStatus["Created"] = "Created";
+    /** KeyVault connection in use by SMB Volume */
+    KnownElasticKeyVaultStatus["InUse"] = "InUse";
+    /** KeyVault connection Deleted */
+    KnownElasticKeyVaultStatus["Deleted"] = "Deleted";
+    /** Error with the KeyVault connection */
+    KnownElasticKeyVaultStatus["Error"] = "Error";
+    /** KeyVault connection Updating */
+    KnownElasticKeyVaultStatus["Updating"] = "Updating";
+})(KnownElasticKeyVaultStatus || (KnownElasticKeyVaultStatus = {}));
+export function elasticEncryptionIdentitySerializer(item) {
+    return {
+        userAssignedIdentity: item["userAssignedIdentity"],
+        federatedClientId: item["federatedClientId"],
+    };
+}
+export function elasticEncryptionIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+        federatedClientId: item["federatedClientId"],
+    };
+}
+export function managedServiceIdentitySerializer(item) {
+    return { type: item["type"], userAssignedIdentities: item["userAssignedIdentities"] };
+}
+export function managedServiceIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        tenantId: item["tenantId"],
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : Object.fromEntries(Object.entries(item["userAssignedIdentities"]).map(([k, p]) => [
+                k,
+                !p ? p : userAssignedIdentityDeserializer(p),
+            ])),
+    };
+}
+/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
+export var KnownManagedServiceIdentityType;
+(function (KnownManagedServiceIdentityType) {
+    /** No managed identity. */
+    KnownManagedServiceIdentityType["None"] = "None";
+    /** System assigned managed identity. */
+    KnownManagedServiceIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** User assigned managed identity. */
+    KnownManagedServiceIdentityType["UserAssigned"] = "UserAssigned";
+    /** System and user assigned managed identity. */
+    KnownManagedServiceIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned,UserAssigned";
+})(KnownManagedServiceIdentityType || (KnownManagedServiceIdentityType = {}));
+export function userAssignedIdentitySerializer(item) {
+    return item;
+}
+export function userAssignedIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+export function elasticAccountUpdateSerializer(item) {
+    return {
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentitySerializer(item["identity"]),
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticAccountUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticAccountUpdatePropertiesSerializer(item) {
+    return {
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : elasticEncryptionSerializer(item["encryption"]),
+    };
+}
+export function _elasticAccountListResultDeserializer(item) {
+    return {
+        value: elasticAccountArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticAccountArraySerializer(result) {
+    return result.map((item) => {
+        return elasticAccountSerializer(item);
+    });
+}
+export function elasticAccountArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticAccountDeserializer(item);
+    });
+}
+export function elasticCapacityPoolSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticCapacityPoolPropertiesSerializer(item["properties"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function elasticCapacityPoolDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticCapacityPoolPropertiesDeserializer(item["properties"]),
+        eTag: item["eTag"],
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function elasticCapacityPoolPropertiesSerializer(item) {
+    return {
+        size: item["size"],
+        serviceLevel: item["serviceLevel"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : elasticEncryptionConfigurationSerializer(item["encryption"]),
+        subnetResourceId: item["subnetResourceId"],
+        activeDirectoryConfigResourceId: item["activeDirectoryConfigResourceId"],
+    };
+}
+export function elasticCapacityPoolPropertiesDeserializer(item) {
+    return {
+        size: item["size"],
+        serviceLevel: item["serviceLevel"],
+        provisioningState: item["provisioningState"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : elasticEncryptionConfigurationDeserializer(item["encryption"]),
+        totalThroughputMibps: item["totalThroughputMibps"],
+        subnetResourceId: item["subnetResourceId"],
+        currentZone: item["currentZone"],
+        availabilityStatus: item["availabilityStatus"],
+        activeDirectoryConfigResourceId: item["activeDirectoryConfigResourceId"],
+    };
+}
+/** Service level for elastic capacity pool */
+export var KnownElasticServiceLevel;
+(function (KnownElasticServiceLevel) {
+    /** Zone redundant storage service level. */
+    KnownElasticServiceLevel["ZoneRedundant"] = "ZoneRedundant";
+})(KnownElasticServiceLevel || (KnownElasticServiceLevel = {}));
+export function elasticEncryptionConfigurationSerializer(item) {
+    return {
+        elasticPoolEncryptionKeySource: item["elasticPoolEncryptionKeySource"],
+        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
+    };
+}
+export function elasticEncryptionConfigurationDeserializer(item) {
+    return {
+        elasticPoolEncryptionKeySource: item["elasticPoolEncryptionKeySource"],
+        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
+    };
+}
+/** Pool Encryption Key Source. */
+export var KnownElasticPoolEncryptionKeySource;
+(function (KnownElasticPoolEncryptionKeySource) {
+    /** Represents the encryption key source of Elastic pool is Microsoft.NetApp */
+    KnownElasticPoolEncryptionKeySource["NetApp"] = "NetApp";
+    /** Represents the encryption key source of Elastic pool is Microsoft.KeyVault */
+    KnownElasticPoolEncryptionKeySource["KeyVault"] = "KeyVault";
+})(KnownElasticPoolEncryptionKeySource || (KnownElasticPoolEncryptionKeySource = {}));
+/** Current availability status of the resource. */
+export var KnownElasticResourceAvailabilityStatus;
+(function (KnownElasticResourceAvailabilityStatus) {
+    /** The resource is currently Online and accessible */
+    KnownElasticResourceAvailabilityStatus["Online"] = "Online";
+    /** The resource is currently Offline and not accessible */
+    KnownElasticResourceAvailabilityStatus["Offline"] = "Offline";
+})(KnownElasticResourceAvailabilityStatus || (KnownElasticResourceAvailabilityStatus = {}));
+export function elasticCapacityPoolUpdateSerializer(item) {
+    return {
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticCapacityPoolUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticCapacityPoolUpdatePropertiesSerializer(item) {
+    return {
+        size: item["size"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : elasticEncryptionConfigurationSerializer(item["encryption"]),
+        activeDirectoryConfigResourceId: item["activeDirectoryConfigResourceId"],
+    };
+}
+export function _elasticCapacityPoolListResultDeserializer(item) {
+    return {
+        value: elasticCapacityPoolArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticCapacityPoolArraySerializer(result) {
+    return result.map((item) => {
+        return elasticCapacityPoolSerializer(item);
+    });
+}
+export function elasticCapacityPoolArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticCapacityPoolDeserializer(item);
+    });
+}
+export function changeZoneRequestSerializer(item) {
+    return { newZone: item["newZone"] };
+}
+export function checkElasticVolumeFilePathAvailabilityRequestSerializer(item) {
+    return { filePath: item["filePath"] };
+}
+export function checkElasticResourceAvailabilityResponseDeserializer(item) {
+    return {
+        isAvailable: item["isAvailable"],
+        reason: item["reason"],
+        message: item["message"],
+    };
+}
+/** Availability status */
+export var KnownCheckElasticResourceAvailabilityStatus;
+(function (KnownCheckElasticResourceAvailabilityStatus) {
+    /** Value indicating the name is valid and available */
+    KnownCheckElasticResourceAvailabilityStatus["True"] = "True";
+    /** Value indicating the the name is invalid, unavailable, or both. */
+    KnownCheckElasticResourceAvailabilityStatus["False"] = "False";
+})(KnownCheckElasticResourceAvailabilityStatus || (KnownCheckElasticResourceAvailabilityStatus = {}));
+/** Availability reason */
+export var KnownCheckElasticResourceAvailabilityReason;
+(function (KnownCheckElasticResourceAvailabilityReason) {
+    /** Value indicating the name provided does not match Azure NetApp Files naming requirements */
+    KnownCheckElasticResourceAvailabilityReason["Invalid"] = "Invalid";
+    /** Value indicating the name is already in use and is therefore unavailable */
+    KnownCheckElasticResourceAvailabilityReason["AlreadyExists"] = "AlreadyExists";
+})(KnownCheckElasticResourceAvailabilityReason || (KnownCheckElasticResourceAvailabilityReason = {}));
+export function elasticVolumeSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticVolumePropertiesSerializer(item["properties"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function elasticVolumeDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticVolumePropertiesDeserializer(item["properties"]),
+        eTag: item["eTag"],
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function elasticVolumePropertiesSerializer(item) {
+    return {
+        filePath: item["filePath"],
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : elasticExportPolicySerializer(item["exportPolicy"]),
+        protocolTypes: item["protocolTypes"].map((p) => {
+            return p;
+        }),
+        snapshotResourceId: item["snapshotResourceId"],
+        dataProtection: !item["dataProtection"]
+            ? item["dataProtection"]
+            : elasticVolumeDataProtectionPropertiesSerializer(item["dataProtection"]),
+        snapshotDirectoryVisibility: item["snapshotDirectoryVisibility"],
+        smbProperties: !item["smbProperties"]
+            ? item["smbProperties"]
+            : elasticSmbPropertiesSerializer(item["smbProperties"]),
+        backupResourceId: item["backupResourceId"],
+    };
+}
+export function elasticVolumePropertiesDeserializer(item) {
+    return {
+        filePath: item["filePath"],
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : elasticExportPolicyDeserializer(item["exportPolicy"]),
+        protocolTypes: item["protocolTypes"].map((p) => {
+            return p;
+        }),
+        provisioningState: item["provisioningState"],
+        availabilityStatus: item["availabilityStatus"],
+        snapshotResourceId: item["snapshotResourceId"],
+        mountTargets: !item["mountTargets"]
+            ? item["mountTargets"]
+            : elasticMountTargetPropertiesArrayDeserializer(item["mountTargets"]),
+        dataProtection: !item["dataProtection"]
+            ? item["dataProtection"]
+            : elasticVolumeDataProtectionPropertiesDeserializer(item["dataProtection"]),
+        snapshotDirectoryVisibility: item["snapshotDirectoryVisibility"],
+        smbProperties: !item["smbProperties"]
+            ? item["smbProperties"]
+            : elasticSmbPropertiesDeserializer(item["smbProperties"]),
+        backupResourceId: item["backupResourceId"],
+        restorationState: item["restorationState"],
+    };
+}
+export function elasticExportPolicySerializer(item) {
+    return {
+        rules: !item["rules"] ? item["rules"] : elasticExportPolicyRuleArraySerializer(item["rules"]),
+    };
+}
+export function elasticExportPolicyDeserializer(item) {
+    return {
+        rules: !item["rules"] ? item["rules"] : elasticExportPolicyRuleArrayDeserializer(item["rules"]),
+    };
+}
+export function elasticExportPolicyRuleArraySerializer(result) {
+    return result.map((item) => {
+        return elasticExportPolicyRuleSerializer(item);
+    });
+}
+export function elasticExportPolicyRuleArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticExportPolicyRuleDeserializer(item);
+    });
+}
+export function elasticExportPolicyRuleSerializer(item) {
+    return {
+        ruleIndex: item["ruleIndex"],
+        unixAccessRule: item["unixAccessRule"],
+        nfsv3: item["nfsv3"],
+        nfsv4: item["nfsv4"],
+        allowedClients: !item["allowedClients"]
+            ? item["allowedClients"]
+            : item["allowedClients"].map((p) => {
+                return p;
+            }),
+        rootAccess: item["rootAccess"],
+    };
+}
+export function elasticExportPolicyRuleDeserializer(item) {
+    return {
+        ruleIndex: item["ruleIndex"],
+        unixAccessRule: item["unixAccessRule"],
+        nfsv3: item["nfsv3"],
+        nfsv4: item["nfsv4"],
+        allowedClients: !item["allowedClients"]
+            ? item["allowedClients"]
+            : item["allowedClients"].map((p) => {
+                return p;
+            }),
+        rootAccess: item["rootAccess"],
+    };
+}
+/** Unix access rule */
+export var KnownElasticUnixAccessRule;
+(function (KnownElasticUnixAccessRule) {
+    /** Clients connecting with this rule will only have read access to the volume */
+    KnownElasticUnixAccessRule["ReadOnly"] = "ReadOnly";
+    /** Clients connecting with this rule will have full read and write access to the volume */
+    KnownElasticUnixAccessRule["ReadWrite"] = "ReadWrite";
+    /** Clients connecting with this rule will have no access to the volume */
+    KnownElasticUnixAccessRule["NoAccess"] = "NoAccess";
+})(KnownElasticUnixAccessRule || (KnownElasticUnixAccessRule = {}));
+/** NFSv3 access */
+export var KnownElasticNfsv3Access;
+(function (KnownElasticNfsv3Access) {
+    /** Clients can connect to the volume using the NFSv3 protocol. */
+    KnownElasticNfsv3Access["Enabled"] = "Enabled";
+    /** Clients can't connect to the volume using the NFSv3 protocol. */
+    KnownElasticNfsv3Access["Disabled"] = "Disabled";
+})(KnownElasticNfsv3Access || (KnownElasticNfsv3Access = {}));
+/** NFSv4 access */
+export var KnownElasticNfsv4Access;
+(function (KnownElasticNfsv4Access) {
+    /** Clients can connect to the volume using the NFSv4 protocol. */
+    KnownElasticNfsv4Access["Enabled"] = "Enabled";
+    /** Clients can't connect to the volume using the NFSv4 protocol. */
+    KnownElasticNfsv4Access["Disabled"] = "Disabled";
+})(KnownElasticNfsv4Access || (KnownElasticNfsv4Access = {}));
+/** Root access */
+export var KnownElasticRootAccess;
+(function (KnownElasticRootAccess) {
+    /** Root user access is enabled for clients affected by this rule */
+    KnownElasticRootAccess["Enabled"] = "Enabled";
+    /** Root user access is disabled for clients affected by this rule */
+    KnownElasticRootAccess["Disabled"] = "Disabled";
+})(KnownElasticRootAccess || (KnownElasticRootAccess = {}));
+/** Protocol types for elastic volume */
+export var KnownElasticProtocolType;
+(function (KnownElasticProtocolType) {
+    /** NFSv3 protocol type */
+    KnownElasticProtocolType["NFSv3"] = "NFSv3";
+    /** NFSv4 protocol type */
+    KnownElasticProtocolType["NFSv4"] = "NFSv4";
+    /** SMB/CIFS protocol type */
+    KnownElasticProtocolType["SMB"] = "SMB";
+})(KnownElasticProtocolType || (KnownElasticProtocolType = {}));
+export function elasticMountTargetPropertiesArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticMountTargetPropertiesDeserializer(item);
+    });
+}
+export function elasticMountTargetPropertiesDeserializer(item) {
+    return {
+        ipAddress: item["ipAddress"],
+        smbServerFqdn: item["smbServerFqdn"],
+    };
+}
+export function elasticVolumeDataProtectionPropertiesSerializer(item) {
+    return {
+        snapshot: !item["snapshot"]
+            ? item["snapshot"]
+            : elasticVolumeSnapshotPropertiesSerializer(item["snapshot"]),
+        backup: !item["backup"]
+            ? item["backup"]
+            : elasticVolumeBackupPropertiesSerializer(item["backup"]),
+    };
+}
+export function elasticVolumeDataProtectionPropertiesDeserializer(item) {
+    return {
+        snapshot: !item["snapshot"]
+            ? item["snapshot"]
+            : elasticVolumeSnapshotPropertiesDeserializer(item["snapshot"]),
+        backup: !item["backup"]
+            ? item["backup"]
+            : elasticVolumeBackupPropertiesDeserializer(item["backup"]),
+    };
+}
+export function elasticVolumeSnapshotPropertiesSerializer(item) {
+    return { snapshotPolicyResourceId: item["snapshotPolicyResourceId"] };
+}
+export function elasticVolumeSnapshotPropertiesDeserializer(item) {
+    return {
+        snapshotPolicyResourceId: item["snapshotPolicyResourceId"],
+    };
+}
+export function elasticVolumeBackupPropertiesSerializer(item) {
+    return {
+        elasticBackupPolicyResourceId: item["elasticBackupPolicyResourceId"],
+        policyEnforcement: item["policyEnforcement"],
+        elasticBackupVaultResourceId: item["elasticBackupVaultResourceId"],
+    };
+}
+export function elasticVolumeBackupPropertiesDeserializer(item) {
+    return {
+        elasticBackupPolicyResourceId: item["elasticBackupPolicyResourceId"],
+        policyEnforcement: item["policyEnforcement"],
+        elasticBackupVaultResourceId: item["elasticBackupVaultResourceId"],
+    };
+}
+/** Policy enforcement */
+export var KnownElasticVolumePolicyEnforcement;
+(function (KnownElasticVolumePolicyEnforcement) {
+    /** Value indicating the policy is enforced on the volume. */
+    KnownElasticVolumePolicyEnforcement["Enforced"] = "Enforced";
+    /** Value indicating the policy is not enforced on the volume. */
+    KnownElasticVolumePolicyEnforcement["NotEnforced"] = "NotEnforced";
+})(KnownElasticVolumePolicyEnforcement || (KnownElasticVolumePolicyEnforcement = {}));
+/** Controls the visibility of the Elastic Volume's read-only snapshot directory, which provides access to each of the volume's snapshots. */
+export var KnownSnapshotDirectoryVisibility;
+(function (KnownSnapshotDirectoryVisibility) {
+    /** Value indicating the read-only snapshot directory is not visible */
+    KnownSnapshotDirectoryVisibility["Hidden"] = "Hidden";
+    /** Value indicating the read-only snapshot directory is visible */
+    KnownSnapshotDirectoryVisibility["Visible"] = "Visible";
+})(KnownSnapshotDirectoryVisibility || (KnownSnapshotDirectoryVisibility = {}));
+export function elasticSmbPropertiesSerializer(item) {
+    return { smbEncryption: item["smbEncryption"] };
+}
+export function elasticSmbPropertiesDeserializer(item) {
+    return {
+        smbEncryption: item["smbEncryption"],
+    };
+}
+/** SMB encryption */
+export var KnownElasticSmbEncryption;
+(function (KnownElasticSmbEncryption) {
+    /** Value indicating the SMB encryption is enabled */
+    KnownElasticSmbEncryption["Enabled"] = "Enabled";
+    /** Value indicating the SMB encryption is disabled */
+    KnownElasticSmbEncryption["Disabled"] = "Disabled";
+})(KnownElasticSmbEncryption || (KnownElasticSmbEncryption = {}));
+/** The current state of the restoration process. */
+export var KnownElasticVolumeRestorationState;
+(function (KnownElasticVolumeRestorationState) {
+    /** Value indicating that the volume is currently restoring. */
+    KnownElasticVolumeRestorationState["Restoring"] = "Restoring";
+    /** Value indicating that the volume is restored. */
+    KnownElasticVolumeRestorationState["Restored"] = "Restored";
+    /** Value indicating that the volume restore has failed. */
+    KnownElasticVolumeRestorationState["Failed"] = "Failed";
+})(KnownElasticVolumeRestorationState || (KnownElasticVolumeRestorationState = {}));
+export function elasticVolumeUpdateSerializer(item) {
+    return {
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticVolumeUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticVolumeUpdatePropertiesSerializer(item) {
+    return {
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : elasticExportPolicySerializer(item["exportPolicy"]),
+        dataProtection: !item["dataProtection"]
+            ? item["dataProtection"]
+            : elasticVolumeDataProtectionPatchPropertiesSerializer(item["dataProtection"]),
+        snapshotDirectoryVisibility: item["snapshotDirectoryVisibility"],
+        smbProperties: !item["smbProperties"]
+            ? item["smbProperties"]
+            : elasticSmbPatchPropertiesSerializer(item["smbProperties"]),
+    };
+}
+export function elasticVolumeDataProtectionPatchPropertiesSerializer(item) {
+    return {
+        snapshot: !item["snapshot"]
+            ? item["snapshot"]
+            : elasticVolumeSnapshotPropertiesSerializer(item["snapshot"]),
+        backup: !item["backup"]
+            ? item["backup"]
+            : elasticVolumeBackupPropertiesSerializer(item["backup"]),
+    };
+}
+export function elasticSmbPatchPropertiesSerializer(item) {
+    return { smbEncryption: item["smbEncryption"] };
+}
+export function _elasticVolumeListResultDeserializer(item) {
+    return {
+        value: elasticVolumeArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticVolumeArraySerializer(result) {
+    return result.map((item) => {
+        return elasticVolumeSerializer(item);
+    });
+}
+export function elasticVolumeArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticVolumeDeserializer(item);
+    });
+}
+export function elasticVolumeRevertSerializer(item) {
+    return { snapshotResourceId: item["snapshotResourceId"] };
+}
+export function elasticSnapshotSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticSnapshotPropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticSnapshotDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticSnapshotPropertiesDeserializer(item["properties"]),
+    };
+}
+export function elasticSnapshotPropertiesSerializer(item) {
+    return item;
+}
+export function elasticSnapshotPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+    };
+}
+export function _elasticSnapshotListResultDeserializer(item) {
+    return {
+        value: elasticSnapshotArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticSnapshotArraySerializer(result) {
+    return result.map((item) => {
+        return elasticSnapshotSerializer(item);
+    });
+}
+export function elasticSnapshotArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticSnapshotDeserializer(item);
+    });
+}
+export function elasticSnapshotPolicySerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticSnapshotPolicyPropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticSnapshotPolicyDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticSnapshotPolicyPropertiesDeserializer(item["properties"]),
+        eTag: item["eTag"],
+    };
+}
+export function elasticSnapshotPolicyPropertiesSerializer(item) {
+    return {
+        hourlySchedule: !item["hourlySchedule"]
+            ? item["hourlySchedule"]
+            : elasticSnapshotPolicyHourlyScheduleSerializer(item["hourlySchedule"]),
+        dailySchedule: !item["dailySchedule"]
+            ? item["dailySchedule"]
+            : elasticSnapshotPolicyDailyScheduleSerializer(item["dailySchedule"]),
+        weeklySchedule: !item["weeklySchedule"]
+            ? item["weeklySchedule"]
+            : elasticSnapshotPolicyWeeklyScheduleSerializer(item["weeklySchedule"]),
+        monthlySchedule: !item["monthlySchedule"]
+            ? item["monthlySchedule"]
+            : elasticSnapshotPolicyMonthlyScheduleSerializer(item["monthlySchedule"]),
+        policyStatus: item["policyStatus"],
+    };
+}
+export function elasticSnapshotPolicyPropertiesDeserializer(item) {
+    return {
+        hourlySchedule: !item["hourlySchedule"]
+            ? item["hourlySchedule"]
+            : elasticSnapshotPolicyHourlyScheduleDeserializer(item["hourlySchedule"]),
+        dailySchedule: !item["dailySchedule"]
+            ? item["dailySchedule"]
+            : elasticSnapshotPolicyDailyScheduleDeserializer(item["dailySchedule"]),
+        weeklySchedule: !item["weeklySchedule"]
+            ? item["weeklySchedule"]
+            : elasticSnapshotPolicyWeeklyScheduleDeserializer(item["weeklySchedule"]),
+        monthlySchedule: !item["monthlySchedule"]
+            ? item["monthlySchedule"]
+            : elasticSnapshotPolicyMonthlyScheduleDeserializer(item["monthlySchedule"]),
+        policyStatus: item["policyStatus"],
+        provisioningState: item["provisioningState"],
+    };
+}
+export function elasticSnapshotPolicyHourlyScheduleSerializer(item) {
+    return { snapshotsToKeep: item["snapshotsToKeep"], minute: item["minute"] };
+}
+export function elasticSnapshotPolicyHourlyScheduleDeserializer(item) {
+    return {
+        snapshotsToKeep: item["snapshotsToKeep"],
+        minute: item["minute"],
+    };
+}
+export function elasticSnapshotPolicyDailyScheduleSerializer(item) {
+    return { snapshotsToKeep: item["snapshotsToKeep"], hour: item["hour"], minute: item["minute"] };
+}
+export function elasticSnapshotPolicyDailyScheduleDeserializer(item) {
+    return {
+        snapshotsToKeep: item["snapshotsToKeep"],
+        hour: item["hour"],
+        minute: item["minute"],
+    };
+}
+export function elasticSnapshotPolicyWeeklyScheduleSerializer(item) {
+    return {
+        snapshotsToKeep: item["snapshotsToKeep"],
+        days: !item["days"]
+            ? item["days"]
+            : item["days"].map((p) => {
+                return p;
+            }),
+        hour: item["hour"],
+        minute: item["minute"],
+    };
+}
+export function elasticSnapshotPolicyWeeklyScheduleDeserializer(item) {
+    return {
+        snapshotsToKeep: item["snapshotsToKeep"],
+        days: !item["days"]
+            ? item["days"]
+            : item["days"].map((p) => {
+                return p;
+            }),
+        hour: item["hour"],
+        minute: item["minute"],
+    };
+}
+/** Day of the week */
+export var KnownDayOfWeek;
+(function (KnownDayOfWeek) {
+    /** Take a snapshot each Sunday */
+    KnownDayOfWeek["Sunday"] = "Sunday";
+    /** Take a snapshot each Monday */
+    KnownDayOfWeek["Monday"] = "Monday";
+    /** Take a snapshot each Tuesday */
+    KnownDayOfWeek["Tuesday"] = "Tuesday";
+    /** Take a snapshot each Wednesday */
+    KnownDayOfWeek["Wednesday"] = "Wednesday";
+    /** Take a snapshot each Thursday */
+    KnownDayOfWeek["Thursday"] = "Thursday";
+    /** Take a snapshot each Friday */
+    KnownDayOfWeek["Friday"] = "Friday";
+    /** Take a snapshot each Saturday */
+    KnownDayOfWeek["Saturday"] = "Saturday";
+})(KnownDayOfWeek || (KnownDayOfWeek = {}));
+export function elasticSnapshotPolicyMonthlyScheduleSerializer(item) {
+    return {
+        snapshotsToKeep: item["snapshotsToKeep"],
+        daysOfMonth: !item["daysOfMonth"]
+            ? item["daysOfMonth"]
+            : item["daysOfMonth"].map((p) => {
+                return p;
+            }),
+        hour: item["hour"],
+        minute: item["minute"],
+    };
+}
+export function elasticSnapshotPolicyMonthlyScheduleDeserializer(item) {
+    return {
+        snapshotsToKeep: item["snapshotsToKeep"],
+        daysOfMonth: !item["daysOfMonth"]
+            ? item["daysOfMonth"]
+            : item["daysOfMonth"].map((p) => {
+                return p;
+            }),
+        hour: item["hour"],
+        minute: item["minute"],
+    };
+}
+/** Policy status */
+export var KnownPolicyStatus;
+(function (KnownPolicyStatus) {
+    /** Value indicating the policy is enabled */
+    KnownPolicyStatus["Enabled"] = "Enabled";
+    /** Value indicating the policy is disabled */
+    KnownPolicyStatus["Disabled"] = "Disabled";
+})(KnownPolicyStatus || (KnownPolicyStatus = {}));
+export function elasticSnapshotPolicyUpdateSerializer(item) {
+    return {
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticSnapshotPolicyUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticSnapshotPolicyUpdatePropertiesSerializer(item) {
+    return {
+        hourlySchedule: !item["hourlySchedule"]
+            ? item["hourlySchedule"]
+            : elasticSnapshotPolicyHourlyScheduleSerializer(item["hourlySchedule"]),
+        dailySchedule: !item["dailySchedule"]
+            ? item["dailySchedule"]
+            : elasticSnapshotPolicyDailyScheduleSerializer(item["dailySchedule"]),
+        weeklySchedule: !item["weeklySchedule"]
+            ? item["weeklySchedule"]
+            : elasticSnapshotPolicyWeeklyScheduleSerializer(item["weeklySchedule"]),
+        monthlySchedule: !item["monthlySchedule"]
+            ? item["monthlySchedule"]
+            : elasticSnapshotPolicyMonthlyScheduleSerializer(item["monthlySchedule"]),
+        policyStatus: item["policyStatus"],
+    };
+}
+export function _elasticSnapshotPolicyListResultDeserializer(item) {
+    return {
+        value: elasticSnapshotPolicyArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticSnapshotPolicyArraySerializer(result) {
+    return result.map((item) => {
+        return elasticSnapshotPolicySerializer(item);
+    });
+}
+export function elasticSnapshotPolicyArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticSnapshotPolicyDeserializer(item);
+    });
+}
+export function _elasticSnapshotPolicyVolumeListDeserializer(item) {
+    return {
+        value: elasticVolumeArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticBackupVaultSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticBackupVaultPropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticBackupVaultDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticBackupVaultPropertiesDeserializer(item["properties"]),
+        eTag: item["eTag"],
+    };
+}
+export function elasticBackupVaultPropertiesSerializer(item) {
+    return item;
+}
+export function elasticBackupVaultPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+    };
+}
+export function elasticBackupVaultUpdateSerializer(item) {
+    return { tags: item["tags"] };
+}
+export function _elasticBackupVaultListResultDeserializer(item) {
+    return {
+        value: elasticBackupVaultArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticBackupVaultArraySerializer(result) {
+    return result.map((item) => {
+        return elasticBackupVaultSerializer(item);
+    });
+}
+export function elasticBackupVaultArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticBackupVaultDeserializer(item);
+    });
+}
+export function elasticBackupPolicySerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticBackupPolicyPropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticBackupPolicyDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticBackupPolicyPropertiesDeserializer(item["properties"]),
+        eTag: item["eTag"],
+    };
+}
+export function elasticBackupPolicyPropertiesSerializer(item) {
+    return {
+        dailyBackupsToKeep: item["dailyBackupsToKeep"],
+        weeklyBackupsToKeep: item["weeklyBackupsToKeep"],
+        monthlyBackupsToKeep: item["monthlyBackupsToKeep"],
+        policyState: item["policyState"],
+    };
+}
+export function elasticBackupPolicyPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        dailyBackupsToKeep: item["dailyBackupsToKeep"],
+        weeklyBackupsToKeep: item["weeklyBackupsToKeep"],
+        monthlyBackupsToKeep: item["monthlyBackupsToKeep"],
+        assignedVolumesCount: item["assignedVolumesCount"],
+        policyState: item["policyState"],
+    };
+}
+/** Elastic Backup Policy state */
+export var KnownElasticBackupPolicyState;
+(function (KnownElasticBackupPolicyState) {
+    /** Value indicating the policy is enabled */
+    KnownElasticBackupPolicyState["Enabled"] = "Enabled";
+    /** Value indicating the policy is disabled */
+    KnownElasticBackupPolicyState["Disabled"] = "Disabled";
+})(KnownElasticBackupPolicyState || (KnownElasticBackupPolicyState = {}));
+export function elasticBackupPolicyUpdateSerializer(item) {
+    return {
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticBackupPolicyUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticBackupPolicyUpdatePropertiesSerializer(item) {
+    return {
+        dailyBackupsToKeep: item["dailyBackupsToKeep"],
+        weeklyBackupsToKeep: item["weeklyBackupsToKeep"],
+        monthlyBackupsToKeep: item["monthlyBackupsToKeep"],
+        policyState: item["policyState"],
+    };
+}
+export function _elasticBackupPolicyListResultDeserializer(item) {
+    return {
+        value: elasticBackupPolicyArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticBackupPolicyArraySerializer(result) {
+    return result.map((item) => {
+        return elasticBackupPolicySerializer(item);
+    });
+}
+export function elasticBackupPolicyArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticBackupPolicyDeserializer(item);
+    });
+}
+export function elasticBackupSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticBackupPropertiesSerializer(item["properties"]),
+    };
+}
+export function elasticBackupDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : elasticBackupPropertiesDeserializer(item["properties"]),
+    };
+}
+export function elasticBackupPropertiesSerializer(item) {
+    return {
+        label: item["label"],
+        elasticVolumeResourceId: item["elasticVolumeResourceId"],
+        snapshotUsage: item["snapshotUsage"],
+        elasticSnapshotResourceId: item["elasticSnapshotResourceId"],
+    };
+}
+export function elasticBackupPropertiesDeserializer(item) {
+    return {
+        creationDate: !item["creationDate"] ? item["creationDate"] : new Date(item["creationDate"]),
+        snapshotCreationDate: !item["snapshotCreationDate"]
+            ? item["snapshotCreationDate"]
+            : new Date(item["snapshotCreationDate"]),
+        completionDate: !item["completionDate"]
+            ? item["completionDate"]
+            : new Date(item["completionDate"]),
+        provisioningState: item["provisioningState"],
+        size: item["size"],
+        label: item["label"],
+        backupType: item["backupType"],
+        failureReason: item["failureReason"],
+        elasticVolumeResourceId: item["elasticVolumeResourceId"],
+        snapshotUsage: item["snapshotUsage"],
+        elasticSnapshotResourceId: item["elasticSnapshotResourceId"],
+        elasticBackupPolicyResourceId: item["elasticBackupPolicyResourceId"],
+        volumeSize: item["volumeSize"],
+    };
+}
+/** Type of backup */
+export var KnownElasticBackupType;
+(function (KnownElasticBackupType) {
+    /** Manual backup type */
+    KnownElasticBackupType["Manual"] = "Manual";
+    /** Scheduled backup type */
+    KnownElasticBackupType["Scheduled"] = "Scheduled";
+})(KnownElasticBackupType || (KnownElasticBackupType = {}));
+/** Snapshot usage for backup */
+export var KnownSnapshotUsage;
+(function (KnownSnapshotUsage) {
+    /** Value indicating an existing snapshot is used */
+    KnownSnapshotUsage["UseExistingSnapshot"] = "UseExistingSnapshot";
+    /** Value indicating a new snapshot is created */
+    KnownSnapshotUsage["CreateNewSnapshot"] = "CreateNewSnapshot";
+})(KnownSnapshotUsage || (KnownSnapshotUsage = {}));
+/** Volume size for backup */
+export var KnownVolumeSize;
+(function (KnownVolumeSize) {
+    /** Value indicating backup is for a large volume */
+    KnownVolumeSize["Large"] = "Large";
+    /** Value indicating backup is not for a large volume */
+    KnownVolumeSize["Regular"] = "Regular";
+})(KnownVolumeSize || (KnownVolumeSize = {}));
+export function _elasticBackupListResultDeserializer(item) {
+    return {
+        value: elasticBackupArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function elasticBackupArraySerializer(result) {
+    return result.map((item) => {
+        return elasticBackupSerializer(item);
+    });
+}
+export function elasticBackupArrayDeserializer(result) {
+    return result.map((item) => {
+        return elasticBackupDeserializer(item);
+    });
+}
+export function activeDirectoryConfigSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : activeDirectoryConfigPropertiesSerializer(item["properties"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentitySerializer(item["identity"]),
+    };
+}
+export function activeDirectoryConfigDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : activeDirectoryConfigPropertiesDeserializer(item["properties"]),
+        etag: item["etag"],
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentityDeserializer(item["identity"]),
+    };
+}
+export function activeDirectoryConfigPropertiesSerializer(item) {
+    return {
+        userName: item["userName"],
+        dns: !item["dns"]
+            ? item["dns"]
+            : item["dns"].map((p) => {
+                return p;
+            }),
+        smbServerName: item["smbServerName"],
+        organizationalUnit: item["organizationalUnit"],
+        site: item["site"],
+        backupOperators: !item["backupOperators"]
+            ? item["backupOperators"]
+            : item["backupOperators"].map((p) => {
+                return p;
+            }),
+        administrators: !item["administrators"]
+            ? item["administrators"]
+            : item["administrators"].map((p) => {
+                return p;
+            }),
+        securityOperators: !item["securityOperators"]
+            ? item["securityOperators"]
+            : item["securityOperators"].map((p) => {
+                return p;
+            }),
+        domain: item["domain"],
+        secretPassword: secretPasswordSerializer(item["secretPassword"]),
+    };
+}
+export function activeDirectoryConfigPropertiesDeserializer(item) {
+    return {
+        userName: item["userName"],
+        dns: !item["dns"]
+            ? item["dns"]
+            : item["dns"].map((p) => {
+                return p;
+            }),
+        smbServerName: item["smbServerName"],
+        organizationalUnit: item["organizationalUnit"],
+        site: item["site"],
+        backupOperators: !item["backupOperators"]
+            ? item["backupOperators"]
+            : item["backupOperators"].map((p) => {
+                return p;
+            }),
+        administrators: !item["administrators"]
+            ? item["administrators"]
+            : item["administrators"].map((p) => {
+                return p;
+            }),
+        securityOperators: !item["securityOperators"]
+            ? item["securityOperators"]
+            : item["securityOperators"].map((p) => {
+                return p;
+            }),
+        activeDirectoryStatus: item["activeDirectoryStatus"],
+        provisioningState: item["provisioningState"],
+        domain: item["domain"],
+        secretPassword: secretPasswordDeserializer(item["secretPassword"]),
+    };
+}
+/** Status of the Active Directory */
+export var KnownActiveDirectoryStatus;
+(function (KnownActiveDirectoryStatus) {
+    /** Active Directory created but not in use */
+    KnownActiveDirectoryStatus["Created"] = "Created";
+    /** Active Directory in use by SMB Volume */
+    KnownActiveDirectoryStatus["InUse"] = "InUse";
+    /** Active Directory Deleted */
+    KnownActiveDirectoryStatus["Deleted"] = "Deleted";
+    /** Error with the Active Directory */
+    KnownActiveDirectoryStatus["Error"] = "Error";
+    /** Active Directory Updating */
+    KnownActiveDirectoryStatus["Updating"] = "Updating";
+})(KnownActiveDirectoryStatus || (KnownActiveDirectoryStatus = {}));
+export function secretPasswordSerializer(item) {
+    return {
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : secretPasswordKeyVaultPropertiesSerializer(item["keyVaultProperties"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : secretPasswordIdentitySerializer(item["identity"]),
+    };
+}
+export function secretPasswordDeserializer(item) {
+    return {
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : secretPasswordKeyVaultPropertiesDeserializer(item["keyVaultProperties"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : secretPasswordIdentityDeserializer(item["identity"]),
+    };
+}
+export function secretPasswordKeyVaultPropertiesSerializer(item) {
+    return { keyVaultUri: item["keyVaultUri"], secretName: item["secretName"] };
+}
+export function secretPasswordKeyVaultPropertiesDeserializer(item) {
+    return {
+        keyVaultUri: item["keyVaultUri"],
+        secretName: item["secretName"],
+    };
+}
+export function secretPasswordIdentitySerializer(item) {
+    return { userAssignedIdentity: item["userAssignedIdentity"] };
+}
+export function secretPasswordIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+export function activeDirectoryConfigUpdateSerializer(item) {
+    return {
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentitySerializer(item["identity"]),
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : activeDirectoryConfigUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function activeDirectoryConfigUpdatePropertiesSerializer(item) {
+    return {
+        userName: item["userName"],
+        dns: !item["dns"]
+            ? item["dns"]
+            : item["dns"].map((p) => {
+                return p;
+            }),
+        smbServerName: item["smbServerName"],
+        organizationalUnit: item["organizationalUnit"],
+        site: item["site"],
+        backupOperators: !item["backupOperators"]
+            ? item["backupOperators"]
+            : item["backupOperators"].map((p) => {
+                return p;
+            }),
+        administrators: !item["administrators"]
+            ? item["administrators"]
+            : item["administrators"].map((p) => {
+                return p;
+            }),
+        securityOperators: !item["securityOperators"]
+            ? item["securityOperators"]
+            : item["securityOperators"].map((p) => {
+                return p;
+            }),
+        domain: item["domain"],
+        secretPassword: !item["secretPassword"]
+            ? item["secretPassword"]
+            : secretPasswordSerializer(item["secretPassword"]),
+    };
+}
+export function _activeDirectoryConfigListResultDeserializer(item) {
+    return {
+        value: activeDirectoryConfigArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function activeDirectoryConfigArraySerializer(result) {
+    return result.map((item) => {
+        return activeDirectoryConfigSerializer(item);
+    });
+}
+export function activeDirectoryConfigArrayDeserializer(result) {
+    return result.map((item) => {
+        return activeDirectoryConfigDeserializer(item);
+    });
+}
+export function regionInfoResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : regionInfoDeserializer(item["properties"]),
+    };
+}
+export function regionInfoDeserializer(item) {
+    return {
+        storageToNetworkProximity: item["storageToNetworkProximity"],
+        availabilityZoneMappings: !item["availabilityZoneMappings"]
+            ? item["availabilityZoneMappings"]
+            : regionInfoAvailabilityZoneMappingsItemArrayDeserializer(item["availabilityZoneMappings"]),
+    };
+}
+/** Provides storage to network proximity information in the region. */
+export var KnownRegionStorageToNetworkProximity;
+(function (KnownRegionStorageToNetworkProximity) {
+    /** Basic network connectivity. */
+    KnownRegionStorageToNetworkProximity["Default"] = "Default";
+    /** Standard T1 network connectivity. */
+    KnownRegionStorageToNetworkProximity["T1"] = "T1";
+    /** Standard T2 network connectivity. */
+    KnownRegionStorageToNetworkProximity["T2"] = "T2";
+    /** Standard AcrossT2 network connectivity. */
+    KnownRegionStorageToNetworkProximity["AcrossT2"] = "AcrossT2";
+    /** Standard T1 and T2 network connectivity. */
+    KnownRegionStorageToNetworkProximity["T1AndT2"] = "T1AndT2";
+    /** Standard T1 and AcrossT2 network connectivity. */
+    KnownRegionStorageToNetworkProximity["T1AndAcrossT2"] = "T1AndAcrossT2";
+    /** Standard T2 and AcrossT2 network connectivity. */
+    KnownRegionStorageToNetworkProximity["T2AndAcrossT2"] = "T2AndAcrossT2";
+    /** Standard T1, T2 and AcrossT2 network connectivity. */
+    KnownRegionStorageToNetworkProximity["T1AndT2AndAcrossT2"] = "T1AndT2AndAcrossT2";
+})(KnownRegionStorageToNetworkProximity || (KnownRegionStorageToNetworkProximity = {}));
+export function regionInfoAvailabilityZoneMappingsItemArrayDeserializer(result) {
+    return result.map((item) => {
+        return regionInfoAvailabilityZoneMappingsItemDeserializer(item);
+    });
+}
+export function regionInfoAvailabilityZoneMappingsItemDeserializer(item) {
+    return {
+        availabilityZone: item["availabilityZone"],
+        isAvailable: item["isAvailable"],
+    };
+}
+export function _regionInfosListDeserializer(item) {
+    return {
+        value: regionInfoResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function regionInfoResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return regionInfoResourceDeserializer(item);
+    });
+}
+export function netAppAccountSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : accountPropertiesSerializer(item["properties"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentitySerializer(item["identity"]),
+    };
+}
+export function netAppAccountDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : accountPropertiesDeserializer(item["properties"]),
+        etag: item["etag"],
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentityDeserializer(item["identity"]),
+    };
+}
+export function accountPropertiesSerializer(item) {
+    return {
+        activeDirectories: !item["activeDirectories"]
+            ? item["activeDirectories"]
+            : activeDirectoryArraySerializer(item["activeDirectories"]),
+        entraIdConfig: !item["entraIdConfig"]
+            ? item["entraIdConfig"]
+            : entraIdConfigSerializer(item["entraIdConfig"]),
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : accountEncryptionSerializer(item["encryption"]),
+        nfsV4IDDomain: item["nfsV4IDDomain"],
+        ldapConfiguration: !item["ldapConfiguration"]
+            ? item["ldapConfiguration"]
+            : ldapConfigurationSerializer(item["ldapConfiguration"]),
+    };
+}
+export function accountPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        activeDirectories: !item["activeDirectories"]
+            ? item["activeDirectories"]
+            : activeDirectoryArrayDeserializer(item["activeDirectories"]),
+        entraIdConfig: !item["entraIdConfig"]
+            ? item["entraIdConfig"]
+            : entraIdConfigDeserializer(item["entraIdConfig"]),
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : accountEncryptionDeserializer(item["encryption"]),
+        disableShowmount: item["disableShowmount"],
+        nfsV4IDDomain: item["nfsV4IDDomain"],
+        multiAdStatus: item["multiAdStatus"],
+        ldapConfiguration: !item["ldapConfiguration"]
+            ? item["ldapConfiguration"]
+            : ldapConfigurationDeserializer(item["ldapConfiguration"]),
+    };
+}
+export function activeDirectoryArraySerializer(result) {
+    return result.map((item) => {
+        return activeDirectorySerializer(item);
+    });
+}
+export function activeDirectoryArrayDeserializer(result) {
+    return result.map((item) => {
+        return activeDirectoryDeserializer(item);
+    });
+}
+export function activeDirectorySerializer(item) {
+    return {
+        activeDirectoryId: item["activeDirectoryId"],
+        username: item["username"],
+        password: item["password"],
+        domain: item["domain"],
+        dns: item["dns"],
+        smbServerName: item["smbServerName"],
+        organizationalUnit: item["organizationalUnit"],
+        site: item["site"],
+        backupOperators: !item["backupOperators"]
+            ? item["backupOperators"]
+            : item["backupOperators"].map((p) => {
+                return p;
+            }),
+        administrators: !item["administrators"]
+            ? item["administrators"]
+            : item["administrators"].map((p) => {
+                return p;
+            }),
+        kdcIP: item["kdcIP"],
+        adName: item["adName"],
+        serverRootCACertificate: item["serverRootCACertificate"],
+        aesEncryption: item["aesEncryption"],
+        ldapSigning: item["ldapSigning"],
+        securityOperators: !item["securityOperators"]
+            ? item["securityOperators"]
+            : item["securityOperators"].map((p) => {
+                return p;
+            }),
         ldapOverTLS: item["ldapOverTLS"],
         allowLocalNfsUsersWithLdap: item["allowLocalNfsUsersWithLdap"],
         encryptDCConnections: item["encryptDCConnections"],
@@ -2051,20 +4157,6 @@ export function activeDirectoryDeserializer(item) {
         preferredServersForLdapClient: item["preferredServersForLdapClient"],
     };
 }
-/** Status of the Active Directory */
-export var KnownActiveDirectoryStatus;
-(function (KnownActiveDirectoryStatus) {
-    /** Active Directory created but not in use */
-    KnownActiveDirectoryStatus["Created"] = "Created";
-    /** Active Directory in use by SMB Volume */
-    KnownActiveDirectoryStatus["InUse"] = "InUse";
-    /** Active Directory Deleted */
-    KnownActiveDirectoryStatus["Deleted"] = "Deleted";
-    /** Error with the Active Directory */
-    KnownActiveDirectoryStatus["Error"] = "Error";
-    /** Active Directory Updating */
-    KnownActiveDirectoryStatus["Updating"] = "Updating";
-})(KnownActiveDirectoryStatus || (KnownActiveDirectoryStatus = {}));
 export function ldapSearchScopeOptSerializer(item) {
     return {
         userDN: item["userDN"],
@@ -2079,6 +4171,40 @@ export function ldapSearchScopeOptDeserializer(item) {
         groupMembershipFilter: item["groupMembershipFilter"],
     };
 }
+export function entraIdConfigSerializer(item) {
+    return {
+        applicationId: item["applicationId"],
+        domain: item["domain"],
+        serverNamePrefix: item["serverNamePrefix"],
+        entraIdAkvConfig: !item["entraIdAkvConfig"]
+            ? item["entraIdAkvConfig"]
+            : entraIdAkvConfigSerializer(item["entraIdAkvConfig"]),
+    };
+}
+export function entraIdConfigDeserializer(item) {
+    return {
+        applicationId: item["applicationId"],
+        domain: item["domain"],
+        serverNamePrefix: item["serverNamePrefix"],
+        entraIdAkvConfig: !item["entraIdAkvConfig"]
+            ? item["entraIdAkvConfig"]
+            : entraIdAkvConfigDeserializer(item["entraIdAkvConfig"]),
+    };
+}
+export function entraIdAkvConfigSerializer(item) {
+    return {
+        azureKeyVaultUri: item["azureKeyVaultUri"],
+        certificateName: item["certificateName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+export function entraIdAkvConfigDeserializer(item) {
+    return {
+        azureKeyVaultUri: item["azureKeyVaultUri"],
+        certificateName: item["certificateName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
 export function accountEncryptionSerializer(item) {
     return {
         keySource: item["keySource"],
@@ -2099,14 +4225,6 @@ export function accountEncryptionDeserializer(item) {
             : encryptionIdentityDeserializer(item["identity"]),
     };
 }
-/** The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.NetApp, Microsoft.KeyVault */
-export var KnownKeySource;
-(function (KnownKeySource) {
-    /** Microsoft-managed key encryption */
-    KnownKeySource["MicrosoftNetApp"] = "Microsoft.NetApp";
-    /** Customer-managed key encryption */
-    KnownKeySource["MicrosoftKeyVault"] = "Microsoft.KeyVault";
-})(KnownKeySource || (KnownKeySource = {}));
 export function keyVaultPropertiesSerializer(item) {
     return {
         keyVaultUri: item["keyVaultUri"],
@@ -2158,41 +4276,30 @@ export var KnownMultiAdStatus;
     /** Account is MultiAD enabled */
     KnownMultiAdStatus["Enabled"] = "Enabled";
 })(KnownMultiAdStatus || (KnownMultiAdStatus = {}));
-export function managedServiceIdentitySerializer(item) {
-    return { type: item["type"], userAssignedIdentities: item["userAssignedIdentities"] };
-}
-export function managedServiceIdentityDeserializer(item) {
+export function ldapConfigurationSerializer(item) {
     return {
-        principalId: item["principalId"],
-        tenantId: item["tenantId"],
-        type: item["type"],
-        userAssignedIdentities: !item["userAssignedIdentities"]
-            ? item["userAssignedIdentities"]
-            : Object.fromEntries(Object.entries(item["userAssignedIdentities"]).map(([k, p]) => [
-                k,
-                !p ? p : userAssignedIdentityDeserializer(p),
-            ])),
+        domain: item["domain"],
+        ldapServers: !item["ldapServers"]
+            ? item["ldapServers"]
+            : item["ldapServers"].map((p) => {
+                return p;
+            }),
+        ldapOverTLS: item["ldapOverTLS"],
+        serverCACertificate: item["serverCACertificate"],
+        certificateCNHost: item["certificateCNHost"],
     };
 }
-/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
-export var KnownManagedServiceIdentityType;
-(function (KnownManagedServiceIdentityType) {
-    /** No managed identity. */
-    KnownManagedServiceIdentityType["None"] = "None";
-    /** System assigned managed identity. */
-    KnownManagedServiceIdentityType["SystemAssigned"] = "SystemAssigned";
-    /** User assigned managed identity. */
-    KnownManagedServiceIdentityType["UserAssigned"] = "UserAssigned";
-    /** System and user assigned managed identity. */
-    KnownManagedServiceIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned,UserAssigned";
-})(KnownManagedServiceIdentityType || (KnownManagedServiceIdentityType = {}));
-export function userAssignedIdentitySerializer(item) {
-    return item;
-}
-export function userAssignedIdentityDeserializer(item) {
+export function ldapConfigurationDeserializer(item) {
     return {
-        principalId: item["principalId"],
-        clientId: item["clientId"],
+        domain: item["domain"],
+        ldapServers: !item["ldapServers"]
+            ? item["ldapServers"]
+            : item["ldapServers"].map((p) => {
+                return p;
+            }),
+        ldapOverTLS: item["ldapOverTLS"],
+        serverCACertificate: item["serverCACertificate"],
+        certificateCNHost: item["certificateCNHost"],
     };
 }
 export function netAppAccountPatchSerializer(item) {
@@ -2201,12 +4308,60 @@ export function netAppAccountPatchSerializer(item) {
         tags: item["tags"],
         properties: !item["properties"]
             ? item["properties"]
-            : accountPropertiesSerializer(item["properties"]),
+            : accountPropertiesPatchSerializer(item["properties"]),
         identity: !item["identity"]
             ? item["identity"]
             : managedServiceIdentitySerializer(item["identity"]),
     };
 }
+export function accountPropertiesPatchSerializer(item) {
+    return {
+        activeDirectories: !item["activeDirectories"]
+            ? item["activeDirectories"]
+            : activeDirectoryArraySerializer(item["activeDirectories"]),
+        entraIdConfig: !item["entraIdConfig"]
+            ? item["entraIdConfig"]
+            : entraIdConfigPatchSerializer(item["entraIdConfig"]),
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : accountEncryptionSerializer(item["encryption"]),
+        nfsV4IDDomain: item["nfsV4IDDomain"],
+        multiAdStatus: item["multiAdStatus"],
+        ldapConfiguration: !item["ldapConfiguration"]
+            ? item["ldapConfiguration"]
+            : ldapConfigurationPatchSerializer(item["ldapConfiguration"]),
+    };
+}
+export function entraIdConfigPatchSerializer(item) {
+    return {
+        applicationId: item["applicationId"],
+        domain: item["domain"],
+        serverNamePrefix: item["serverNamePrefix"],
+        entraIdAkvConfig: !item["entraIdAkvConfig"]
+            ? item["entraIdAkvConfig"]
+            : entraIdAkvConfigPatchSerializer(item["entraIdAkvConfig"]),
+    };
+}
+export function entraIdAkvConfigPatchSerializer(item) {
+    return {
+        azureKeyVaultUri: item["azureKeyVaultUri"],
+        certificateName: item["certificateName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
+}
+export function ldapConfigurationPatchSerializer(item) {
+    return {
+        domain: item["domain"],
+        ldapServers: !item["ldapServers"]
+            ? item["ldapServers"]
+            : item["ldapServers"].map((p) => {
+                return p;
+            }),
+        ldapOverTLS: item["ldapOverTLS"],
+        serverCACertificate: item["serverCACertificate"],
+        certificateCNHost: item["certificateCNHost"],
+    };
+}
 export function _netAppAccountListDeserializer(item) {
     return {
         value: netAppAccountArrayDeserializer(item["value"]),
@@ -2627,5 +4782,7 @@ export var KnownVersions;
     KnownVersions["V20250901"] = "2025-09-01";
     /** The 2025-12-01 API version. */
     KnownVersions["V20251201"] = "2025-12-01";
+    /** The 2025-12-15-preview API version. */
+    KnownVersions["V20251215Preview"] = "2025-12-15-preview";
 })(KnownVersions || (KnownVersions = {}));
 //# sourceMappingURL=models.js.map