@azure/arm-netapp 23.0.0 → 24.0.0

package/dist/browser/models/models.js

@@ -161,8 +161,8 @@ export function quotaItemPropertiesDeserializer(item) {
         usage: item["usage"],
     };
 }
-export function proxyResourceSerializer(item) {
-    return item;
+export function proxyResourceSerializer(_item) {
+    return {};
 }
 export function proxyResourceDeserializer(item) {
     return {
@@ -174,8 +174,8 @@ export function proxyResourceDeserializer(item) {
             : systemDataDeserializer(item["systemData"]),
     };
 }
-export function resourceSerializer(item) {
-    return item;
+export function resourceSerializer(_item) {
+    return {};
 }
 export function resourceDeserializer(item) {
     return {
@@ -666,6 +666,10 @@ export function replicationObjectDeserializer(item) {
         destinationReplications: !item["destinationReplications"]
             ? item["destinationReplications"]
             : destinationReplicationArrayDeserializer(item["destinationReplications"]),
+        externalReplicationSetupStatus: item["externalReplicationSetupStatus"],
+        externalReplicationSetupInfo: item["externalReplicationSetupInfo"],
+        mirrorState: item["mirrorState"],
+        relationshipStatus: item["relationshipStatus"],
     };
 }
 /** Indicates whether the local volume is the source or destination for the Volume Replication */
@@ -721,6 +725,38 @@ export var KnownReplicationType;
     /** Cross zone replication */
     KnownReplicationType["CrossZoneReplication"] = "CrossZoneReplication";
 })(KnownReplicationType || (KnownReplicationType = {}));
+/** Property that only applies to external replications. Provides a machine-readable value for the status of the external replication setup. */
+export var KnownExternalReplicationSetupStatus;
+(function (KnownExternalReplicationSetupStatus) {
+    /** Your cluster needs to be peered by using the 'peerExternalCluster' action */
+    KnownExternalReplicationSetupStatus["ClusterPeerRequired"] = "ClusterPeerRequired";
+    /** The peering needs to be accepted on your cluster before the setup can proceed */
+    KnownExternalReplicationSetupStatus["ClusterPeerPending"] = "ClusterPeerPending";
+    /** Need to call 'authorizeExternalReplication' and accept the returned 'vserver peer accept' command on your cluster to finish setting up the external replication */
+    KnownExternalReplicationSetupStatus["VServerPeerRequired"] = "VServerPeerRequired";
+    /** Need to call 'authorizeExternalReplication' to finish setting up the external replication */
+    KnownExternalReplicationSetupStatus["ReplicationCreateRequired"] = "ReplicationCreateRequired";
+    /** External Replication setup is complete, you can now monitor the 'mirrorState' in the replication status for the health of the replication */
+    KnownExternalReplicationSetupStatus["NoActionRequired"] = "NoActionRequired";
+})(KnownExternalReplicationSetupStatus || (KnownExternalReplicationSetupStatus = {}));
+/** The status of the replication */
+export var KnownMirrorState;
+(function (KnownMirrorState) {
+    /** Uninitialized */
+    KnownMirrorState["Uninitialized"] = "Uninitialized";
+    /** Mirrored */
+    KnownMirrorState["Mirrored"] = "Mirrored";
+    /** Broken */
+    KnownMirrorState["Broken"] = "Broken";
+})(KnownMirrorState || (KnownMirrorState = {}));
+/** Status of the volume replication relationship */
+export var KnownVolumeReplicationRelationshipStatus;
+(function (KnownVolumeReplicationRelationshipStatus) {
+    /** Idle */
+    KnownVolumeReplicationRelationshipStatus["Idle"] = "Idle";
+    /** Transferring */
+    KnownVolumeReplicationRelationshipStatus["Transferring"] = "Transferring";
+})(KnownVolumeReplicationRelationshipStatus || (KnownVolumeReplicationRelationshipStatus = {}));
 export function volumeSnapshotPropertiesSerializer(item) {
     return { snapshotPolicyId: item["snapshotPolicyId"] };
 }
@@ -987,16 +1023,6 @@ export var KnownVolumeBackupRelationshipStatus;
     /** Unknown */
     KnownVolumeBackupRelationshipStatus["Unknown"] = "Unknown";
 })(KnownVolumeBackupRelationshipStatus || (KnownVolumeBackupRelationshipStatus = {}));
-/** The status of the replication */
-export var KnownMirrorState;
-(function (KnownMirrorState) {
-    /** Uninitialized */
-    KnownMirrorState["Uninitialized"] = "Uninitialized";
-    /** Mirrored */
-    KnownMirrorState["Mirrored"] = "Mirrored";
-    /** Broken */
-    KnownMirrorState["Broken"] = "Broken";
-})(KnownMirrorState || (KnownMirrorState = {}));
 export function restoreStatusDeserializer(item) {
     return {
         healthy: item["healthy"],
@@ -1176,14 +1202,6 @@ export function replicationStatusDeserializer(item) {
         errorMessage: item["errorMessage"],
     };
 }
-/** Status of the volume replication relationship */
-export var KnownVolumeReplicationRelationshipStatus;
-(function (KnownVolumeReplicationRelationshipStatus) {
-    /** Idle */
-    KnownVolumeReplicationRelationshipStatus["Idle"] = "Idle";
-    /** Transferring */
-    KnownVolumeReplicationRelationshipStatus["Transferring"] = "Transferring";
-})(KnownVolumeReplicationRelationshipStatus || (KnownVolumeReplicationRelationshipStatus = {}));
 export function listReplicationsRequestSerializer(item) {
     return { exclude: item["exclude"] };
 }
@@ -1244,10 +1262,25 @@ export function peerClusterForVolumeMigrationRequestSerializer(item) {
 }
 export function clusterPeerCommandResponseDeserializer(item) {
     return {
-        peerAcceptCommand: item["peerAcceptCommand"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : clusterPeerCommandResponsePropertiesDeserializer(item["properties"]),
+    };
+}
+export function clusterPeerCommandResponsePropertiesDeserializer(item) {
+    return {
+        clusterPeeringCommand: item["clusterPeeringCommand"],
+        passphrase: item["passphrase"],
     };
 }
 export function svmPeerCommandResponseDeserializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : svmPeerCommandResponsePropertiesDeserializer(item["properties"]),
+    };
+}
+export function svmPeerCommandResponsePropertiesDeserializer(item) {
     return {
         svmPeeringCommand: item["svmPeeringCommand"],
     };
@@ -1328,8 +1361,8 @@ export function snapshotDeserializer(item) {
         location: item["location"],
     };
 }
-export function snapshotPropertiesSerializer(item) {
-    return item;
+export function snapshotPropertiesSerializer(_item) {
+    return {};
 }
 export function snapshotPropertiesDeserializer(item) {
     return {
@@ -1338,8 +1371,8 @@ export function snapshotPropertiesDeserializer(item) {
         provisioningState: item["provisioningState"],
     };
 }
-export function snapshotPatchSerializer(item) {
-    return item;
+export function snapshotPatchSerializer(_item) {
+    return {};
 }
 export function _snapshotsListDeserializer(item) {
     return {
@@ -1813,8 +1846,8 @@ export function backupVaultDeserializer(item) {
             : backupVaultPropertiesDeserializer(item["properties"]),
     };
 }
-export function backupVaultPropertiesSerializer(item) {
-    return item;
+export function backupVaultPropertiesSerializer(_item) {
+    return {};
 }
 export function backupVaultPropertiesDeserializer(item) {
     return {
@@ -1840,6 +1873,693 @@ export function backupVaultArrayDeserializer(result) {
         return backupVaultDeserializer(item);
     });
 }
+export function bucketSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : bucketPropertiesSerializer(item["properties"]),
+    };
+}
+export function bucketDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : bucketPropertiesDeserializer(item["properties"]),
+    };
+}
+export function bucketPropertiesSerializer(item) {
+    return {
+        path: item["path"],
+        fileSystemUser: !item["fileSystemUser"]
+            ? item["fileSystemUser"]
+            : fileSystemUserSerializer(item["fileSystemUser"]),
+        server: !item["server"] ? item["server"] : bucketServerPropertiesSerializer(item["server"]),
+        permissions: item["permissions"],
+        akvDetails: !item["akvDetails"]
+            ? item["akvDetails"]
+            : azureKeyVaultDetailsSerializer(item["akvDetails"]),
+    };
+}
+export function bucketPropertiesDeserializer(item) {
+    return {
+        path: item["path"],
+        fileSystemUser: !item["fileSystemUser"]
+            ? item["fileSystemUser"]
+            : fileSystemUserDeserializer(item["fileSystemUser"]),
+        provisioningState: item["provisioningState"],
+        status: item["status"],
+        server: !item["server"] ? item["server"] : bucketServerPropertiesDeserializer(item["server"]),
+        permissions: item["permissions"],
+        akvDetails: !item["akvDetails"]
+            ? item["akvDetails"]
+            : azureKeyVaultDetailsDeserializer(item["akvDetails"]),
+    };
+}
+export function fileSystemUserSerializer(item) {
+    return {
+        nfsUser: !item["nfsUser"] ? item["nfsUser"] : nfsUserSerializer(item["nfsUser"]),
+        cifsUser: !item["cifsUser"] ? item["cifsUser"] : cifsUserSerializer(item["cifsUser"]),
+    };
+}
+export function fileSystemUserDeserializer(item) {
+    return {
+        nfsUser: !item["nfsUser"] ? item["nfsUser"] : nfsUserDeserializer(item["nfsUser"]),
+        cifsUser: !item["cifsUser"] ? item["cifsUser"] : cifsUserDeserializer(item["cifsUser"]),
+    };
+}
+export function nfsUserSerializer(item) {
+    return { userId: item["userId"], groupId: item["groupId"] };
+}
+export function nfsUserDeserializer(item) {
+    return {
+        userId: item["userId"],
+        groupId: item["groupId"],
+    };
+}
+export function cifsUserSerializer(item) {
+    return { username: item["username"] };
+}
+export function cifsUserDeserializer(item) {
+    return {
+        username: item["username"],
+    };
+}
+/**
+ * The bucket credentials status. There states:
+ *
+ * "NoCredentialsSet": Access and Secret key pair have not been generated.
+ * "CredentialsExpired": Access and Secret key pair have expired.
+ * "Active": The certificate has been installed and credentials are unexpired.
+ */
+export var KnownCredentialsStatus;
+(function (KnownCredentialsStatus) {
+    /** Access and Secret key pair have not been generated. */
+    KnownCredentialsStatus["NoCredentialsSet"] = "NoCredentialsSet";
+    /** Access and Secret key pair have expired. */
+    KnownCredentialsStatus["CredentialsExpired"] = "CredentialsExpired";
+    /** The certificate has been installed on the bucket server and the bucket credentials are unexpired. */
+    KnownCredentialsStatus["Active"] = "Active";
+})(KnownCredentialsStatus || (KnownCredentialsStatus = {}));
+export function bucketServerPropertiesSerializer(item) {
+    return {
+        fqdn: item["fqdn"],
+        certificateObject: item["certificateObject"],
+        onCertificateConflictAction: item["onCertificateConflictAction"],
+    };
+}
+export function bucketServerPropertiesDeserializer(item) {
+    return {
+        fqdn: item["fqdn"],
+        certificateCommonName: item["certificateCommonName"],
+        certificateExpiryDate: !item["certificateExpiryDate"]
+            ? item["certificateExpiryDate"]
+            : new Date(item["certificateExpiryDate"]),
+        ipAddress: item["ipAddress"],
+        certificateObject: item["certificateObject"],
+        onCertificateConflictAction: item["onCertificateConflictAction"],
+    };
+}
+/**
+ * This action is triggered when a certificate conflict occurs. A conflict arises if you try to create a new bucket while one or more already exist on the server, or if you update a bucket when multiple buckets are present. This happens because a single certificate is shared among all buckets on the same server.
+ *
+ * Note: This applies both to certificates provided directly via the certificateObject property and to those retrieved from Azure Key Vault. Details for the latter case are specified in the akvDetails.certificateAkvDetails section.
+ */
+export var KnownOnCertificateConflictAction;
+(function (KnownOnCertificateConflictAction) {
+    /** Update the existing certificate regardless of whether there is a conflict or not. This means all buckets on the server will now use the new certificate. */
+    KnownOnCertificateConflictAction["Update"] = "Update";
+    /** Fail the operation if a conflict occurs, meaning the bucket operation will fail, and the existing certificate will continue to be in use. */
+    KnownOnCertificateConflictAction["Fail"] = "Fail";
+})(KnownOnCertificateConflictAction || (KnownOnCertificateConflictAction = {}));
+/** Access permissions for the bucket. Either ReadOnly or ReadWrite. The default is ReadOnly if no value is provided during bucket creation. */
+export var KnownBucketPermissions;
+(function (KnownBucketPermissions) {
+    /** Read-only access to bucket. */
+    KnownBucketPermissions["ReadOnly"] = "ReadOnly";
+    /** Read-write access to bucket. */
+    KnownBucketPermissions["ReadWrite"] = "ReadWrite";
+})(KnownBucketPermissions || (KnownBucketPermissions = {}));
+export function azureKeyVaultDetailsSerializer(item) {
+    return {
+        certificateAkvDetails: !item["certificateAkvDetails"]
+            ? item["certificateAkvDetails"]
+            : certificateAkvDetailsSerializer(item["certificateAkvDetails"]),
+        credentialsAkvDetails: !item["credentialsAkvDetails"]
+            ? item["credentialsAkvDetails"]
+            : credentialsAkvDetailsSerializer(item["credentialsAkvDetails"]),
+    };
+}
+export function azureKeyVaultDetailsDeserializer(item) {
+    return {
+        certificateAkvDetails: !item["certificateAkvDetails"]
+            ? item["certificateAkvDetails"]
+            : certificateAkvDetailsDeserializer(item["certificateAkvDetails"]),
+        credentialsAkvDetails: !item["credentialsAkvDetails"]
+            ? item["credentialsAkvDetails"]
+            : credentialsAkvDetailsDeserializer(item["credentialsAkvDetails"]),
+    };
+}
+export function certificateAkvDetailsSerializer(item) {
+    return {
+        certificateKeyVaultUri: item["certificateKeyVaultUri"],
+        certificateName: item["certificateName"],
+    };
+}
+export function certificateAkvDetailsDeserializer(item) {
+    return {
+        certificateKeyVaultUri: item["certificateKeyVaultUri"],
+        certificateName: item["certificateName"],
+    };
+}
+export function credentialsAkvDetailsSerializer(item) {
+    return { credentialsKeyVaultUri: item["credentialsKeyVaultUri"], secretName: item["secretName"] };
+}
+export function credentialsAkvDetailsDeserializer(item) {
+    return {
+        credentialsKeyVaultUri: item["credentialsKeyVaultUri"],
+        secretName: item["secretName"],
+    };
+}
+export function bucketPatchSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : bucketPatchPropertiesSerializer(item["properties"]),
+    };
+}
+export function bucketPatchPropertiesSerializer(item) {
+    return {
+        fileSystemUser: !item["fileSystemUser"]
+            ? item["fileSystemUser"]
+            : fileSystemUserSerializer(item["fileSystemUser"]),
+        server: !item["server"]
+            ? item["server"]
+            : bucketServerPatchPropertiesSerializer(item["server"]),
+        permissions: item["permissions"],
+        akvDetails: !item["akvDetails"]
+            ? item["akvDetails"]
+            : azureKeyVaultDetailsSerializer(item["akvDetails"]),
+    };
+}
+export function bucketServerPatchPropertiesSerializer(item) {
+    return {
+        fqdn: item["fqdn"],
+        certificateObject: item["certificateObject"],
+        onCertificateConflictAction: item["onCertificateConflictAction"],
+    };
+}
+/** Access permissions for the bucket. Either ReadOnly or ReadWrite. */
+export var KnownBucketPatchPermissions;
+(function (KnownBucketPatchPermissions) {
+    /** Read-only access to bucket. */
+    KnownBucketPatchPermissions["ReadOnly"] = "ReadOnly";
+    /** Read-write access to bucket. */
+    KnownBucketPatchPermissions["ReadWrite"] = "ReadWrite";
+})(KnownBucketPatchPermissions || (KnownBucketPatchPermissions = {}));
+export function _bucketListDeserializer(item) {
+    return {
+        value: bucketArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function bucketArraySerializer(result) {
+    return result.map((item) => {
+        return bucketSerializer(item);
+    });
+}
+export function bucketArrayDeserializer(result) {
+    return result.map((item) => {
+        return bucketDeserializer(item);
+    });
+}
+export function bucketCredentialsExpirySerializer(item) {
+    return { keyPairExpiryDays: item["keyPairExpiryDays"] };
+}
+export function bucketGenerateCredentialsDeserializer(item) {
+    return {
+        accessKey: item["accessKey"],
+        secretKey: item["secretKey"],
+        keyPairExpiry: !item["keyPairExpiry"] ? item["keyPairExpiry"] : new Date(item["keyPairExpiry"]),
+    };
+}
+export function cacheSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: cachePropertiesSerializer(item["properties"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function cacheDeserializer(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: cachePropertiesDeserializer(item["properties"]),
+        etag: item["etag"],
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function cachePropertiesSerializer(item) {
+    return {
+        filePath: item["filePath"],
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : cachePropertiesExportPolicySerializer(item["exportPolicy"]),
+        protocolTypes: !item["protocolTypes"]
+            ? item["protocolTypes"]
+            : item["protocolTypes"].map((p) => {
+                return p;
+            }),
+        cacheSubnetResourceId: item["cacheSubnetResourceId"],
+        peeringSubnetResourceId: item["peeringSubnetResourceId"],
+        kerberos: item["kerberos"],
+        smbSettings: !item["smbSettings"]
+            ? item["smbSettings"]
+            : smbSettingsSerializer(item["smbSettings"]),
+        throughputMibps: item["throughputMibps"],
+        encryptionKeySource: item["encryptionKeySource"],
+        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
+        ldap: item["ldap"],
+        ldapServerType: item["ldapServerType"],
+        originClusterInformation: originClusterInformationSerializer(item["originClusterInformation"]),
+        cifsChangeNotifications: item["cifsChangeNotifications"],
+        globalFileLocking: item["globalFileLocking"],
+        writeBack: item["writeBack"],
+    };
+}
+export function cachePropertiesDeserializer(item) {
+    return {
+        filePath: item["filePath"],
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : cachePropertiesExportPolicyDeserializer(item["exportPolicy"]),
+        protocolTypes: !item["protocolTypes"]
+            ? item["protocolTypes"]
+            : item["protocolTypes"].map((p) => {
+                return p;
+            }),
+        provisioningState: item["provisioningState"],
+        cacheState: item["cacheState"],
+        cacheSubnetResourceId: item["cacheSubnetResourceId"],
+        peeringSubnetResourceId: item["peeringSubnetResourceId"],
+        mountTargets: !item["mountTargets"]
+            ? item["mountTargets"]
+            : cacheMountTargetPropertiesArrayDeserializer(item["mountTargets"]),
+        kerberos: item["kerberos"],
+        smbSettings: !item["smbSettings"]
+            ? item["smbSettings"]
+            : smbSettingsDeserializer(item["smbSettings"]),
+        throughputMibps: item["throughputMibps"],
+        actualThroughputMibps: item["actualThroughputMibps"],
+        encryptionKeySource: item["encryptionKeySource"],
+        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
+        maximumNumberOfFiles: item["maximumNumberOfFiles"],
+        encryption: item["encryption"],
+        language: item["language"],
+        ldap: item["ldap"],
+        ldapServerType: item["ldapServerType"],
+        originClusterInformation: originClusterInformationDeserializer(item["originClusterInformation"]),
+        cifsChangeNotifications: item["cifsChangeNotifications"],
+        globalFileLocking: item["globalFileLocking"],
+        writeBack: item["writeBack"],
+    };
+}
+export function cachePropertiesExportPolicySerializer(item) {
+    return { rules: !item["rules"] ? item["rules"] : exportPolicyRuleArraySerializer(item["rules"]) };
+}
+export function cachePropertiesExportPolicyDeserializer(item) {
+    return {
+        rules: !item["rules"] ? item["rules"] : exportPolicyRuleArrayDeserializer(item["rules"]),
+    };
+}
+/** Set of supported protocol types, which include NFSv3, NFSv4 and SMB protocol */
+export var KnownProtocolTypes;
+(function (KnownProtocolTypes) {
+    /** NFSv3 protocol type */
+    KnownProtocolTypes["NFSv3"] = "NFSv3";
+    /** NFSv4 protocol type */
+    KnownProtocolTypes["NFSv4"] = "NFSv4";
+    /** SMB protocol type */
+    KnownProtocolTypes["SMB"] = "SMB";
+})(KnownProtocolTypes || (KnownProtocolTypes = {}));
+/** Azure lifecycle management */
+export var KnownCacheProvisioningState;
+(function (KnownCacheProvisioningState) {
+    /** The resource is being created. */
+    KnownCacheProvisioningState["Creating"] = "Creating";
+    /** The resource is being updated. */
+    KnownCacheProvisioningState["Updating"] = "Updating";
+    /** The resource is being deleted. */
+    KnownCacheProvisioningState["Deleting"] = "Deleting";
+    /** The resource is in a failed state. */
+    KnownCacheProvisioningState["Failed"] = "Failed";
+    /** The resource is succeeded. */
+    KnownCacheProvisioningState["Succeeded"] = "Succeeded";
+    /** Resource creation was canceled. */
+    KnownCacheProvisioningState["Canceled"] = "Canceled";
+})(KnownCacheProvisioningState || (KnownCacheProvisioningState = {}));
+/** Azure NetApp Files Cache lifecycle management */
+export var KnownCacheLifeCycleState;
+(function (KnownCacheLifeCycleState) {
+    /** Cluster peering offer has been sent. */
+    KnownCacheLifeCycleState["ClusterPeeringOfferSent"] = "ClusterPeeringOfferSent";
+    /** VServer peering offer has been sent. */
+    KnownCacheLifeCycleState["VserverPeeringOfferSent"] = "VserverPeeringOfferSent";
+    /** Cache creation in progress. */
+    KnownCacheLifeCycleState["Creating"] = "Creating";
+    /** Cache creation succeeded and is available for use. */
+    KnownCacheLifeCycleState["Succeeded"] = "Succeeded";
+    /** Cache is in a failed state */
+    KnownCacheLifeCycleState["Failed"] = "Failed";
+})(KnownCacheLifeCycleState || (KnownCacheLifeCycleState = {}));
+export function cacheMountTargetPropertiesArrayDeserializer(result) {
+    return result.map((item) => {
+        return cacheMountTargetPropertiesDeserializer(item);
+    });
+}
+export function cacheMountTargetPropertiesDeserializer(item) {
+    return {
+        mountTargetId: item["mountTargetId"],
+        ipAddress: item["ipAddress"],
+        smbServerFqdn: item["smbServerFqdn"],
+    };
+}
+/** Describe if a cache is Kerberos enabled. */
+export var KnownKerberosState;
+(function (KnownKerberosState) {
+    /** Kerberos is disabled */
+    KnownKerberosState["Disabled"] = "Disabled";
+    /** Kerberos is enabled */
+    KnownKerberosState["Enabled"] = "Enabled";
+})(KnownKerberosState || (KnownKerberosState = {}));
+export function smbSettingsSerializer(item) {
+    return {
+        smbEncryption: item["smbEncryption"],
+        smbAccessBasedEnumeration: item["smbAccessBasedEnumeration"],
+        smbNonBrowsable: item["smbNonBrowsable"],
+    };
+}
+export function smbSettingsDeserializer(item) {
+    return {
+        smbEncryption: item["smbEncryption"],
+        smbAccessBasedEnumeration: item["smbAccessBasedEnumeration"],
+        smbNonBrowsable: item["smbNonBrowsable"],
+    };
+}
+/** Enables encryption for in-flight smb3 data. Only applicable for SMB/DualProtocol cache */
+export var KnownSmbEncryptionState;
+(function (KnownSmbEncryptionState) {
+    /** SMB encryption is disabled */
+    KnownSmbEncryptionState["Disabled"] = "Disabled";
+    /** SMB encryption is enabled */
+    KnownSmbEncryptionState["Enabled"] = "Enabled";
+})(KnownSmbEncryptionState || (KnownSmbEncryptionState = {}));
+/** Specifies if the cache is encryption or not. */
+export var KnownEncryptionState;
+(function (KnownEncryptionState) {
+    /** Encryption is disabled */
+    KnownEncryptionState["Disabled"] = "Disabled";
+    /** Encryption is enabled */
+    KnownEncryptionState["Enabled"] = "Enabled";
+})(KnownEncryptionState || (KnownEncryptionState = {}));
+/** 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) {
+    /** ldap is disabled. */
+    KnownLdapState["Disabled"] = "Disabled";
+    /** 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"],
+    };
+}
+export function originClusterInformationDeserializer(item) {
+    return {
+        peerClusterName: item["peerClusterName"],
+        peerAddresses: item["peerAddresses"].map((p) => {
+            return p;
+        }),
+        peerVserverName: item["peerVserverName"],
+        peerVolumeName: item["peerVolumeName"],
+    };
+}
+/** Flag indicating whether a CIFS change notification is enabled for the cache. */
+export var KnownCifsChangeNotifyState;
+(function (KnownCifsChangeNotifyState) {
+    /** CIFS change notification is disabled */
+    KnownCifsChangeNotifyState["Disabled"] = "Disabled";
+    /** CIFS change notification is enabled */
+    KnownCifsChangeNotifyState["Enabled"] = "Enabled";
+})(KnownCifsChangeNotifyState || (KnownCifsChangeNotifyState = {}));
+/** Flag indicating whether the global file lock is enabled for the cache. */
+export var KnownGlobalFileLockingState;
+(function (KnownGlobalFileLockingState) {
+    /** Global file locking is disabled */
+    KnownGlobalFileLockingState["Disabled"] = "Disabled";
+    /** Global file locking is enabled */
+    KnownGlobalFileLockingState["Enabled"] = "Enabled";
+})(KnownGlobalFileLockingState || (KnownGlobalFileLockingState = {}));
+/** Flag indicating whether writeback is enabled for the cache. */
+export var KnownEnableWriteBackState;
+(function (KnownEnableWriteBackState) {
+    /** Writeback cache is disabled */
+    KnownEnableWriteBackState["Disabled"] = "Disabled";
+    /** Writeback cache is enabled */
+    KnownEnableWriteBackState["Enabled"] = "Enabled";
+})(KnownEnableWriteBackState || (KnownEnableWriteBackState = {}));
+export function cacheUpdateSerializer(item) {
+    return {
+        tags: item["tags"],
+        properties: !item["properties"]
+            ? item["properties"]
+            : cacheUpdatePropertiesSerializer(item["properties"]),
+    };
+}
+export function cacheUpdatePropertiesSerializer(item) {
+    return {
+        size: item["size"],
+        exportPolicy: !item["exportPolicy"]
+            ? item["exportPolicy"]
+            : cachePropertiesExportPolicySerializer(item["exportPolicy"]),
+        protocolTypes: !item["protocolTypes"]
+            ? item["protocolTypes"]
+            : item["protocolTypes"].map((p) => {
+                return p;
+            }),
+        smbSettings: !item["smbSettings"]
+            ? item["smbSettings"]
+            : smbSettingsSerializer(item["smbSettings"]),
+        throughputMibps: item["throughputMibps"],
+        keyVaultPrivateEndpointResourceId: item["keyVaultPrivateEndpointResourceId"],
+        cifsChangeNotifications: item["cifsChangeNotifications"],
+        writeBack: item["writeBack"],
+    };
+}
+export function _cacheListDeserializer(item) {
+    return {
+        value: cacheArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function cacheArraySerializer(result) {
+    return result.map((item) => {
+        return cacheSerializer(item);
+    });
+}
+export function cacheArrayDeserializer(result) {
+    return result.map((item) => {
+        return cacheDeserializer(item);
+    });
+}
+export function peeringPassphrasesDeserializer(item) {
+    return {
+        clusterPeeringCommand: item["clusterPeeringCommand"],
+        clusterPeeringPassphrase: item["clusterPeeringPassphrase"],
+        vserverPeeringCommand: item["vserverPeeringCommand"],
+        criticalWarning: item["criticalWarning"],
+    };
+}
 export function regionInfoResourceDeserializer(item) {
     return {
         id: item["id"],
@@ -2186,8 +2906,8 @@ export var KnownManagedServiceIdentityType;
     /** System and user assigned managed identity. */
     KnownManagedServiceIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned,UserAssigned";
 })(KnownManagedServiceIdentityType || (KnownManagedServiceIdentityType = {}));
-export function userAssignedIdentitySerializer(item) {
-    return item;
+export function userAssignedIdentitySerializer(_item) {
+    return {};
 }
 export function userAssignedIdentityDeserializer(item) {
     return {
@@ -2627,5 +3347,7 @@ export var KnownVersions;
     KnownVersions["V20250901"] = "2025-09-01";
     /** The 2025-12-01 API version. */
     KnownVersions["V20251201"] = "2025-12-01";
+    /** The 2026-01-01 API version. */
+    KnownVersions["V20260101"] = "2026-01-01";
 })(KnownVersions || (KnownVersions = {}));
 //# sourceMappingURL=models.js.map