@azure/arm-netapp 24.1.0 → 25.0.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 */
@@ -843,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.
@@ -890,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"]),
@@ -2029,21 +2211,28 @@ export function certificateAkvDetailsSerializer(item) {
     return {
         certificateKeyVaultUri: item["certificateKeyVaultUri"],
         certificateName: item["certificateName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
     };
 }
 export function certificateAkvDetailsDeserializer(item) {
     return {
         certificateKeyVaultUri: item["certificateKeyVaultUri"],
         certificateName: item["certificateName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
     };
 }
 export function credentialsAkvDetailsSerializer(item) {
-    return { credentialsKeyVaultUri: item["credentialsKeyVaultUri"], secretName: item["secretName"] };
+    return {
+        credentialsKeyVaultUri: item["credentialsKeyVaultUri"],
+        secretName: item["secretName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
 }
 export function credentialsAkvDetailsDeserializer(item) {
     return {
         credentialsKeyVaultUri: item["credentialsKeyVaultUri"],
         secretName: item["secretName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
     };
 }
 export function bucketPatchSerializer(item) {
@@ -2307,148 +2496,6 @@ export var KnownEncryptionState;
     /** Encryption is enabled */
     KnownEncryptionState["Enabled"] = "Enabled";
 })(KnownEncryptionState || (KnownEncryptionState = {}));
-/** 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 LDAP is enabled or not. */
 export var KnownLdapState;
 (function (KnownLdapState) {
@@ -2457,118 +2504,1467 @@ export var KnownLdapState;
     /** ldap is enabled */
     KnownLdapState["Enabled"] = "Enabled";
 })(KnownLdapState || (KnownLdapState = {}));
-/** 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 = {}));
 export function originClusterInformationSerializer(item) {
     return {
-        peerClusterName: item["peerClusterName"],
-        peerAddresses: item["peerAddresses"].map((p) => {
-            return p;
-        }),
-        peerVserverName: item["peerVserverName"],
-        peerVolumeName: item["peerVolumeName"],
+        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 = {}));
+/** Flag indicating whether file access logs are enabled for the Cache, based on active diagnostic settings present on the Cache. */
+export var KnownCacheFileAccessLogs;
+(function (KnownCacheFileAccessLogs) {
+    /** fileAccessLogs are enabled */
+    KnownCacheFileAccessLogs["Enabled"] = "Enabled";
+    /** fileAccessLogs are not enabled */
+    KnownCacheFileAccessLogs["Disabled"] = "Disabled";
+})(KnownCacheFileAccessLogs || (KnownCacheFileAccessLogs = {}));
+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 {};
+}
+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 {};
+}
+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 {};
+}
+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 originClusterInformationDeserializer(item) {
+export function secretPasswordDeserializer(item) {
     return {
-        peerClusterName: item["peerClusterName"],
-        peerAddresses: item["peerAddresses"].map((p) => {
-            return p;
-        }),
-        peerVserverName: item["peerVserverName"],
-        peerVolumeName: item["peerVolumeName"],
+        keyVaultProperties: !item["keyVaultProperties"]
+            ? item["keyVaultProperties"]
+            : secretPasswordKeyVaultPropertiesDeserializer(item["keyVaultProperties"]),
+        identity: !item["identity"]
+            ? item["identity"]
+            : secretPasswordIdentityDeserializer(item["identity"]),
     };
 }
-/** 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 = {}));
-/** Flag indicating whether file access logs are enabled for the Cache, based on active diagnostic settings present on the Cache. */
-export var KnownCacheFileAccessLogs;
-(function (KnownCacheFileAccessLogs) {
-    /** fileAccessLogs are enabled */
-    KnownCacheFileAccessLogs["Enabled"] = "Enabled";
-    /** fileAccessLogs are not enabled */
-    KnownCacheFileAccessLogs["Disabled"] = "Disabled";
-})(KnownCacheFileAccessLogs || (KnownCacheFileAccessLogs = {}));
-export function cacheUpdateSerializer(item) {
+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"]
-            : cacheUpdatePropertiesSerializer(item["properties"]),
+            : activeDirectoryConfigUpdatePropertiesSerializer(item["properties"]),
     };
 }
-export function cacheUpdatePropertiesSerializer(item) {
+export function activeDirectoryConfigUpdatePropertiesSerializer(item) {
     return {
-        size: item["size"],
-        exportPolicy: !item["exportPolicy"]
-            ? item["exportPolicy"]
-            : cachePropertiesExportPolicySerializer(item["exportPolicy"]),
-        protocolTypes: !item["protocolTypes"]
-            ? item["protocolTypes"]
-            : item["protocolTypes"].map((p) => {
+        userName: item["userName"],
+        dns: !item["dns"]
+            ? item["dns"]
+            : item["dns"].map((p) => {
                 return p;
             }),
-        smbSettings: !item["smbSettings"]
-            ? item["smbSettings"]
-            : smbSettingsSerializer(item["smbSettings"]),
-        throughputMibps: item["throughputMibps"],
-        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
-        cifsChangeNotifications: item["cifsChangeNotifications"],
-        writeBack: item["writeBack"],
+        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 _cacheListDeserializer(item) {
+export function _activeDirectoryConfigListResultDeserializer(item) {
     return {
-        value: cacheArrayDeserializer(item["value"]),
+        value: activeDirectoryConfigArrayDeserializer(item["value"]),
         nextLink: item["nextLink"],
     };
 }
-export function cacheArraySerializer(result) {
+export function activeDirectoryConfigArraySerializer(result) {
     return result.map((item) => {
-        return cacheSerializer(item);
+        return activeDirectoryConfigSerializer(item);
     });
 }
-export function cacheArrayDeserializer(result) {
+export function activeDirectoryConfigArrayDeserializer(result) {
     return result.map((item) => {
-        return cacheDeserializer(item);
+        return activeDirectoryConfigDeserializer(item);
     });
 }
-export function peeringPassphrasesDeserializer(item) {
-    return {
-        clusterPeeringCommand: item["clusterPeeringCommand"],
-        clusterPeeringPassphrase: item["clusterPeeringPassphrase"],
-        vserverPeeringCommand: item["vserverPeeringCommand"],
-        criticalWarning: item["criticalWarning"],
-    };
-}
 export function regionInfoResourceDeserializer(item) {
     return {
         id: item["id"],
@@ -2670,10 +4066,16 @@ export function accountPropertiesSerializer(item) {
         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) {
@@ -2682,12 +4084,18 @@ export function accountPropertiesDeserializer(item) {
         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) {
@@ -2780,20 +4188,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"],
@@ -2808,6 +4202,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"],
@@ -2828,14 +4256,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"],
@@ -2887,53 +4307,132 @@ 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"],
+        bindAuthenticationLevel: item["bindAuthenticationLevel"],
+        bindDN: item["bindDN"],
+        bindPasswordAkvConfig: !item["bindPasswordAkvConfig"]
+            ? item["bindPasswordAkvConfig"]
+            : bindPasswordAkvConfigSerializer(item["bindPasswordAkvConfig"]),
     };
 }
-/** 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 {};
+export function ldapConfigurationDeserializer(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"],
+        bindAuthenticationLevel: item["bindAuthenticationLevel"],
+        bindDN: item["bindDN"],
+        bindPasswordAkvConfig: !item["bindPasswordAkvConfig"]
+            ? item["bindPasswordAkvConfig"]
+            : bindPasswordAkvConfigDeserializer(item["bindPasswordAkvConfig"]),
+    };
+}
+/** The authentication level to use when binding to the LDAP server. */
+export var KnownBindAuthenticationLevel;
+(function (KnownBindAuthenticationLevel) {
+    /** Anonymous bind i.e. no credentials provided */
+    KnownBindAuthenticationLevel["Anonymous"] = "Anonymous";
+    /** Simple bind i.e. plain text credentials provided */
+    KnownBindAuthenticationLevel["Simple"] = "Simple";
+})(KnownBindAuthenticationLevel || (KnownBindAuthenticationLevel = {}));
+export function bindPasswordAkvConfigSerializer(item) {
+    return {
+        azureKeyVaultUri: item["azureKeyVaultUri"],
+        secretName: item["secretName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
+    };
 }
-export function userAssignedIdentityDeserializer(item) {
+export function bindPasswordAkvConfigDeserializer(item) {
     return {
-        principalId: item["principalId"],
-        clientId: item["clientId"],
+        azureKeyVaultUri: item["azureKeyVaultUri"],
+        secretName: item["secretName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
     };
 }
 export function netAppAccountPatchSerializer(item) {
     return {
-        location: item["location"],
-        tags: item["tags"],
-        properties: !item["properties"]
-            ? item["properties"]
-            : accountPropertiesSerializer(item["properties"]),
         identity: !item["identity"]
             ? item["identity"]
             : managedServiceIdentitySerializer(item["identity"]),
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : accountPropertiesPatchSerializer(item["properties"]),
+    };
+}
+export function accountPropertiesPatchSerializer(item) {
+    return {
+        activeDirectories: !item["activeDirectories"]
+            ? item["activeDirectories"]
+            : activeDirectoryArraySerializer(item["activeDirectories"]),
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : accountEncryptionSerializer(item["encryption"]),
+        nfsV4IDDomain: item["nfsV4IDDomain"],
+        entraIdConfig: !item["entraIdConfig"]
+            ? item["entraIdConfig"]
+            : entraIdConfigPatchSerializer(item["entraIdConfig"]),
+        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"],
+        bindAuthenticationLevel: item["bindAuthenticationLevel"],
+        bindDN: item["bindDN"],
+        bindPasswordAkvConfig: !item["bindPasswordAkvConfig"]
+            ? item["bindPasswordAkvConfig"]
+            : bindPasswordAkvConfigPatchSerializer(item["bindPasswordAkvConfig"]),
+    };
+}
+export function bindPasswordAkvConfigPatchSerializer(item) {
+    return {
+        azureKeyVaultUri: item["azureKeyVaultUri"],
+        secretName: item["secretName"],
+        userAssignedIdentity: item["userAssignedIdentity"],
     };
 }
 export function _netAppAccountListDeserializer(item) {
@@ -3356,11 +4855,19 @@ 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";
     /** The 2026-01-01 API version. */
     KnownVersions["V20260101"] = "2026-01-01";
+    /** The 2026-01-15-preview API version. */
+    KnownVersions["V20260115Preview"] = "2026-01-15-preview";
     /** The 2026-03-01 API version. */
     KnownVersions["V20260301"] = "2026-03-01";
+    /** The 2026-03-15-preview API version. */
+    KnownVersions["V20260315Preview"] = "2026-03-15-preview";
     /** The 2026-04-01 API version. */
     KnownVersions["V20260401"] = "2026-04-01";
+    /** The 2026-04-15-preview API version. */
+    KnownVersions["V20260415Preview"] = "2026-04-15-preview";
 })(KnownVersions || (KnownVersions = {}));
 //# sourceMappingURL=models.js.map