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

package/dist/browser/models/models.d.ts

@@ -311,7 +311,11 @@ export interface VolumeProperties {
     creationToken: string;
     /** The service level of the file system */
     serviceLevel?: ServiceLevel;
-    /** Maximum storage quota allowed for a file system in bytes. This is a soft quota used for alerting only. For regular volumes, valid values are in the range 50GiB to 100TiB. For large volumes, valid values are in the range 100TiB to 500TiB, and on an exceptional basis, from to 2400GiB to 2400TiB. Values expressed in bytes as multiples of 1 GiB. */
+    /**
+     * Maximum storage quota allowed for a file system in bytes. This is a soft quota used for alerting only. For regular volumes, valid values are in the range 50GiB to 100TiB.
+     * For large volumes, valid values are in the range 100TiB to 500TiB, and on an exceptional basis, from to 2400GiB to 2400TiB.
+     * For extra large volumes, valid values are in the range 2400GiB to 7200TiB. Values expressed in bytes as multiples of 1 GiB.
+     */
     usageThreshold: number;
     /** Set of export policy rules */
     exportPolicy?: VolumePropertiesExportPolicy;
@@ -371,6 +375,8 @@ export interface VolumeProperties {
     keyVaultPrivateEndpointResourceId?: string;
     /** Specifies whether LDAP is enabled or not for a given NFS volume. */
     ldapEnabled?: boolean;
+    /** Specifies the type of LDAP server for a given NFS volume. */
+    ldapServerType?: LdapServerType;
     /** Specifies whether Cool Access(tiering) is enabled for the volume. */
     coolAccess?: boolean;
     /** Specifies the number of days after which data that is not accessed by clients will be tiered. */
@@ -422,10 +428,20 @@ export interface VolumeProperties {
     readonly provisionedAvailabilityZone?: string | null;
     /** Specifies whether volume is a Large Volume or Regular Volume. */
     isLargeVolume?: boolean;
+    /**
+     * 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.
+     */
+    largeVolumeType?: LargeVolumeType;
     /** Id of the snapshot or backup that the volume is restored from. */
     readonly originatingResourceId?: string | null;
     /** Space shared by short term clone volume with parent volume in bytes. */
     readonly inheritedSizeInBytes?: number | null;
+    /** Language supported for volume. */
+    language?: VolumeLanguage;
+    /** Specifies whether the volume operates in Breakthrough Mode. */
+    breakthroughMode?: BreakthroughMode;
 }
 export declare function volumePropertiesSerializer(item: VolumeProperties): any;
 export declare function volumePropertiesDeserializer(item: any): VolumeProperties;
@@ -613,6 +629,14 @@ export interface ReplicationObject {
     remoteVolumeRegion?: string;
     /** A list of destination replications */
     readonly destinationReplications?: DestinationReplication[];
+    /** Property that only applies to external replications. Provides a machine-readable value for the status of the external replication setup. */
+    readonly externalReplicationSetupStatus?: ExternalReplicationSetupStatus;
+    /** Contains human-readable instructions on what the next step is to finish the external replication setup. */
+    readonly externalReplicationSetupInfo?: string;
+    /** The mirror state property describes the current status of data replication for a replication. It provides insight into whether the data is actively being mirrored, if the replication process has been paused, or if it has yet to be initialized. */
+    readonly mirrorState?: MirrorState;
+    /** The status of the Volume Replication */
+    readonly relationshipStatus?: VolumeReplicationRelationshipStatus;
 }
 export declare function replicationObjectSerializer(item: ReplicationObject): any;
 export declare function replicationObjectDeserializer(item: any): ReplicationObject;
@@ -691,6 +715,66 @@ export declare enum KnownReplicationType {
  * **CrossZoneReplication**: Cross zone replication
  */
 export type ReplicationType = string;
+/** Property that only applies to external replications. Provides a machine-readable value for the status of the external replication setup. */
+export declare enum KnownExternalReplicationSetupStatus {
+    /** Your cluster needs to be peered by using the 'peerExternalCluster' action */
+    ClusterPeerRequired = "ClusterPeerRequired",
+    /** The peering needs to be accepted on your cluster before the setup can proceed */
+    ClusterPeerPending = "ClusterPeerPending",
+    /** Need to call 'authorizeExternalReplication' and accept the returned 'vserver peer accept' command on your cluster to finish setting up the external replication */
+    VServerPeerRequired = "VServerPeerRequired",
+    /** Need to call 'authorizeExternalReplication' to finish setting up the external replication */
+    ReplicationCreateRequired = "ReplicationCreateRequired",
+    /** External Replication setup is complete, you can now monitor the 'mirrorState' in the replication status for the health of the replication */
+    NoActionRequired = "NoActionRequired"
+}
+/**
+ * Property that only applies to external replications. Provides a machine-readable value for the status of the external replication setup. \
+ * {@link KnownExternalReplicationSetupStatus} can be used interchangeably with ExternalReplicationSetupStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ClusterPeerRequired**: Your cluster needs to be peered by using the 'peerExternalCluster' action \
+ * **ClusterPeerPending**: The peering needs to be accepted on your cluster before the setup can proceed \
+ * **VServerPeerRequired**: Need to call 'authorizeExternalReplication' and accept the returned 'vserver peer accept' command on your cluster to finish setting up the external replication \
+ * **ReplicationCreateRequired**: Need to call 'authorizeExternalReplication' to finish setting up the external replication \
+ * **NoActionRequired**: External Replication setup is complete, you can now monitor the 'mirrorState' in the replication status for the health of the replication
+ */
+export type ExternalReplicationSetupStatus = string;
+/** The status of the replication */
+export declare enum KnownMirrorState {
+    /** Uninitialized */
+    Uninitialized = "Uninitialized",
+    /** Mirrored */
+    Mirrored = "Mirrored",
+    /** Broken */
+    Broken = "Broken"
+}
+/**
+ * The status of the replication \
+ * {@link KnownMirrorState} can be used interchangeably with MirrorState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Uninitialized** \
+ * **Mirrored** \
+ * **Broken**
+ */
+export type MirrorState = string;
+/** Status of the volume replication relationship */
+export declare enum KnownVolumeReplicationRelationshipStatus {
+    /** Idle */
+    Idle = "Idle",
+    /** Transferring */
+    Transferring = "Transferring"
+}
+/**
+ * Status of the volume replication relationship \
+ * {@link KnownVolumeReplicationRelationshipStatus} can be used interchangeably with VolumeReplicationRelationshipStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Idle** \
+ * **Transferring**
+ */
+export type VolumeReplicationRelationshipStatus = string;
 /** Volume Snapshot Properties */
 export interface VolumeSnapshotProperties {
     /** Snapshot Policy ResourceId */
@@ -834,6 +918,22 @@ export declare enum KnownEncryptionKeySource {
  * **Microsoft.KeyVault**: Customer-managed key encryption
  */
 export type EncryptionKeySource = string;
+/** The type of the LDAP server */
+export declare enum KnownLdapServerType {
+    /** The volume should use Active Directory for LDAP connections. */
+    ActiveDirectory = "ActiveDirectory",
+    /** The volume should use OpenLDAP for LDAP connections. */
+    OpenLdap = "OpenLDAP"
+}
+/**
+ * The type of the LDAP server \
+ * {@link KnownLdapServerType} can be used interchangeably with LdapServerType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ActiveDirectory**: The volume should use Active Directory for LDAP connections. \
+ * **OpenLDAP**: The volume should use OpenLDAP for LDAP connections.
+ */
+export type LdapServerType = string;
 /**
  * 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.
@@ -925,6 +1025,267 @@ export declare enum KnownEnableSubvolumes {
  * **Disabled**: subvolumes are not enabled
  */
 export type EnableSubvolumes = string;
+/**
+ * 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 declare enum KnownLargeVolumeType {
+    /** The large volume is created with standard configuration that provides standard performance and throughput. */
+    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 */
+    ExtraLargeVolume7Dot2PiB = "PremExtraLargeVolume7Dot2PiB"
+}
+/**
+ * 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. \
+ * {@link KnownLargeVolumeType} can be used interchangeably with LargeVolumeType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **LargeVolume**: The large volume is created with standard configuration that provides standard performance and throughput. \
+ * **PremExtraLargeVolume7Dot2PiB**: The extra large volume is created with higher volume capacity limit 7.2PiB with cool access enabled, delivering higher capacity limit with lower costs
+ */
+export type LargeVolumeType = string;
+/** Language supported for volume. */
+export declare enum KnownVolumeLanguage {
+    /** Posix with UTF-8 */
+    CUtf8 = "c.utf-8",
+    /** UTF-8 with 4 byte character support */
+    Utf8Mb4 = "utf8mb4",
+    /** Arabic - Deprecated */
+    Ar = "ar",
+    /** Arabic with UTF-8 */
+    ArUtf8 = "ar.utf-8",
+    /** Croatian - Deprecated */
+    Hr = "hr",
+    /** Croatian with UTF-8 */
+    HrUtf8 = "hr.utf-8",
+    /** Czech - Deprecated */
+    Cs = "cs",
+    /** Czech with UTF-8 */
+    CsUtf8 = "cs.utf-8",
+    /** Danish - Deprecated */
+    Da = "da",
+    /** Danish with UTF-8 */
+    DaUtf8 = "da.utf-8",
+    /** Dutch - Deprecated */
+    Nl = "nl",
+    /** Dutch with UTF-8 */
+    NlUtf8 = "nl.utf-8",
+    /** English - Deprecated */
+    En = "en",
+    /** English with UTF-8 */
+    EnUtf8 = "en.utf-8",
+    /** Finnish - Deprecated */
+    Fi = "fi",
+    /** Finnish with UTF-8 */
+    FiUtf8 = "fi.utf-8",
+    /** French - Deprecated */
+    Fr = "fr",
+    /** French with UTF-8 */
+    FrUtf8 = "fr.utf-8",
+    /** German - Deprecated */
+    De = "de",
+    /** German with UTF-8 */
+    DeUtf8 = "de.utf-8",
+    /** Hebrew - Deprecated */
+    He = "he",
+    /** Hebrew with UTF-8 */
+    HeUtf8 = "he.utf-8",
+    /** Hungarian - Deprecated */
+    Hu = "hu",
+    /** Hungarian with UTF-8 */
+    HuUtf8 = "hu.utf-8",
+    /** Italian - Deprecated */
+    It = "it",
+    /** Italian with UTF-8 */
+    ItUtf8 = "it.utf-8",
+    /** Japanese euc-j - Deprecated */
+    Ja = "ja",
+    /** Japanese euc-j with UTF-8 */
+    JaUtf8 = "ja.utf-8",
+    /** Japanese euc-j - Deprecated */
+    JaV1 = "ja-v1",
+    /** Japanese euc-j with UTF-8 */
+    JaV1Utf8 = "ja-v1.utf-8",
+    /** Japanese pck */
+    JaJpPck = "ja-jp.pck",
+    /** Japanese pck with UTF-8 - Deprecated */
+    JaJpPckUtf8 = "ja-jp.pck.utf-8",
+    /** Japanese cp932 */
+    JaJp932 = "ja-jp.932",
+    /** Japanese cp932 with UTF-8 - Deprecated */
+    JaJp932Utf8 = "ja-jp.932.utf-8",
+    /** Japanese pck - sjis */
+    JaJpPckV2 = "ja-jp.pck-v2",
+    /** Japanese pck - sjis with UTF-8 - Deprecated */
+    JaJpPckV2Utf8 = "ja-jp.pck-v2.utf-8",
+    /** Korean - Deprecated */
+    Ko = "ko",
+    /** Korean with UTF-8 */
+    KoUtf8 = "ko.utf-8",
+    /** Norwegian - Deprecated */
+    No = "no",
+    /** Norwegian with UTF-8 */
+    NoUtf8 = "no.utf-8",
+    /** Polish - Deprecated */
+    Pl = "pl",
+    /** Polish with UTF-8 */
+    PlUtf8 = "pl.utf-8",
+    /** Portuguese - Deprecated */
+    Pt = "pt",
+    /** Portuguese with UTF-8 */
+    PtUtf8 = "pt.utf-8",
+    /** Posix - Deprecated */
+    C = "c",
+    /** Romanian - Deprecated */
+    Ro = "ro",
+    /** Romanian with UTF-8 */
+    RoUtf8 = "ro.utf-8",
+    /** Russian - Deprecated */
+    Ru = "ru",
+    /** Russian with UTF-8 */
+    RuUtf8 = "ru.utf-8",
+    /** Simplified Chinese - Deprecated */
+    Zh = "zh",
+    /** Simplified Chinese with UTF-8 */
+    ZhUtf8 = "zh.utf-8",
+    /** Simplified gbk Chinese */
+    ZhGbk = "zh.gbk",
+    /** Simplified gbk Chinese with UTF-8 - Deprecated */
+    ZhGbkUtf8 = "zh.gbk.utf-8",
+    /** Traditional Chinese BIG 5 */
+    ZhTwBig5 = "zh-tw.big5",
+    /** Traditional Chinese BIG 5 with UTF-8 - Deprecated */
+    ZhTwBig5Utf8 = "zh-tw.big5.utf-8",
+    /** Traditional Chinese EUC-TW */
+    ZhTw = "zh-tw",
+    /** Traditional Chinese EUC-TW with UTF-8 - Deprecated */
+    ZhTwUtf8 = "zh-tw.utf-8",
+    /** Slovak - Deprecated */
+    Sk = "sk",
+    /** Slovak with UTF-8 */
+    SkUtf8 = "sk.utf-8",
+    /** Slovenian - Deprecated */
+    Sl = "sl",
+    /** Slovenian with UTF-8 */
+    SlUtf8 = "sl.utf-8",
+    /** Spanish - Deprecated */
+    Es = "es",
+    /** Spanish with UTF-8 */
+    EsUtf8 = "es.utf-8",
+    /** Swedish - Deprecated */
+    Sv = "sv",
+    /** Swedish with UTF-8 */
+    SvUtf8 = "sv.utf-8",
+    /** Turkish - Deprecated */
+    Tr = "tr",
+    /** Turkish with UTF-8 */
+    TrUtf8 = "tr.utf-8",
+    /** US English - Deprecated */
+    EnUs = "en-us",
+    /** US English with UTF-8 */
+    EnUsUtf8 = "en-us.utf-8"
+}
+/**
+ * Language supported for volume. \
+ * {@link KnownVolumeLanguage} can be used interchangeably with VolumeLanguage,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **c.utf-8**: Posix with UTF-8 \
+ * **utf8mb4**: UTF-8 with 4 byte character support \
+ * **ar**: Arabic - Deprecated \
+ * **ar.utf-8**: Arabic with UTF-8 \
+ * **hr**: Croatian - Deprecated \
+ * **hr.utf-8**: Croatian with UTF-8 \
+ * **cs**: Czech - Deprecated \
+ * **cs.utf-8**: Czech with UTF-8 \
+ * **da**: Danish - Deprecated \
+ * **da.utf-8**: Danish with UTF-8 \
+ * **nl**: Dutch - Deprecated \
+ * **nl.utf-8**: Dutch with UTF-8 \
+ * **en**: English - Deprecated \
+ * **en.utf-8**: English with UTF-8 \
+ * **fi**: Finnish - Deprecated \
+ * **fi.utf-8**: Finnish with UTF-8 \
+ * **fr**: French - Deprecated \
+ * **fr.utf-8**: French with UTF-8 \
+ * **de**: German - Deprecated \
+ * **de.utf-8**: German with UTF-8 \
+ * **he**: Hebrew - Deprecated \
+ * **he.utf-8**: Hebrew with UTF-8 \
+ * **hu**: Hungarian - Deprecated \
+ * **hu.utf-8**: Hungarian with UTF-8 \
+ * **it**: Italian - Deprecated \
+ * **it.utf-8**: Italian with UTF-8 \
+ * **ja**: Japanese euc-j - Deprecated \
+ * **ja.utf-8**: Japanese euc-j with UTF-8 \
+ * **ja-v1**: Japanese euc-j - Deprecated \
+ * **ja-v1.utf-8**: Japanese euc-j with UTF-8 \
+ * **ja-jp.pck**: Japanese pck \
+ * **ja-jp.pck.utf-8**: Japanese pck with UTF-8 - Deprecated \
+ * **ja-jp.932**: Japanese cp932 \
+ * **ja-jp.932.utf-8**: Japanese cp932 with UTF-8 - Deprecated \
+ * **ja-jp.pck-v2**: Japanese pck - sjis \
+ * **ja-jp.pck-v2.utf-8**: Japanese pck - sjis with UTF-8 - Deprecated \
+ * **ko**: Korean - Deprecated \
+ * **ko.utf-8**: Korean with UTF-8 \
+ * **no**: Norwegian - Deprecated \
+ * **no.utf-8**: Norwegian with UTF-8 \
+ * **pl**: Polish - Deprecated \
+ * **pl.utf-8**: Polish with UTF-8 \
+ * **pt**: Portuguese - Deprecated \
+ * **pt.utf-8**: Portuguese with UTF-8 \
+ * **c**: Posix - Deprecated \
+ * **ro**: Romanian - Deprecated \
+ * **ro.utf-8**: Romanian with UTF-8 \
+ * **ru**: Russian - Deprecated \
+ * **ru.utf-8**: Russian with UTF-8 \
+ * **zh**: Simplified Chinese - Deprecated \
+ * **zh.utf-8**: Simplified Chinese with UTF-8 \
+ * **zh.gbk**: Simplified gbk Chinese \
+ * **zh.gbk.utf-8**: Simplified gbk Chinese with UTF-8 - Deprecated \
+ * **zh-tw.big5**: Traditional Chinese BIG 5 \
+ * **zh-tw.big5.utf-8**: Traditional Chinese BIG 5 with UTF-8 - Deprecated \
+ * **zh-tw**: Traditional Chinese EUC-TW \
+ * **zh-tw.utf-8**: Traditional Chinese EUC-TW with UTF-8 - Deprecated \
+ * **sk**: Slovak - Deprecated \
+ * **sk.utf-8**: Slovak with UTF-8 \
+ * **sl**: Slovenian - Deprecated \
+ * **sl.utf-8**: Slovenian with UTF-8 \
+ * **es**: Spanish - Deprecated \
+ * **es.utf-8**: Spanish with UTF-8 \
+ * **sv**: Swedish - Deprecated \
+ * **sv.utf-8**: Swedish with UTF-8 \
+ * **tr**: Turkish - Deprecated \
+ * **tr.utf-8**: Turkish with UTF-8 \
+ * **en-us**: US English - Deprecated \
+ * **en-us.utf-8**: US English with UTF-8
+ */
+export type VolumeLanguage = string;
+/**
+ * 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 declare enum KnownBreakthroughMode {
+    /** The volume runs on the resources configured for Breakthrough mode which ensures consistent high performance and a higher throughput. */
+    Enabled = "Enabled",
+    /** The volume uses configuration that provides basic performance and throughput. */
+    Disabled = "Disabled"
+}
+/**
+ * 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. \
+ * {@link KnownBreakthroughMode} can be used interchangeably with BreakthroughMode,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: The volume runs on the resources configured for Breakthrough mode which ensures consistent high performance and a higher throughput. \
+ * **Disabled**: The volume uses configuration that provides basic performance and throughput.
+ */
+export type BreakthroughMode = string;
 /** List of volume group resources */
 export interface _VolumeGroupList {
     /** The VolumeGroup items on this page */
@@ -1078,25 +1439,6 @@ export declare enum KnownVolumeBackupRelationshipStatus {
  * **Unknown**
  */
 export type VolumeBackupRelationshipStatus = string;
-/** The status of the replication */
-export declare enum KnownMirrorState {
-    /** Uninitialized */
-    Uninitialized = "Uninitialized",
-    /** Mirrored */
-    Mirrored = "Mirrored",
-    /** Broken */
-    Broken = "Broken"
-}
-/**
- * The status of the replication \
- * {@link KnownMirrorState} can be used interchangeably with MirrorState,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **Uninitialized** \
- * **Mirrored** \
- * **Broken**
- */
-export type MirrorState = string;
 /** Restore status */
 export interface RestoreStatus {
     /** Restore health status */
@@ -1175,7 +1517,11 @@ export declare function volumePatchSerializer(item: VolumePatch): any;
 export interface VolumePatchProperties {
     /** The service level of the file system */
     serviceLevel?: ServiceLevel;
-    /** Maximum storage quota allowed for a file system in bytes. This is a soft quota used for alerting only. For regular volumes, valid values are in the range 50GiB to 100TiB. For large volumes, valid values are in the range 100TiB to 500TiB, and on an exceptional basis, from to 2400GiB to 2400TiB. Values expressed in bytes as multiples of 1 GiB. */
+    /**
+     * Maximum storage quota allowed for a file system in bytes. This is a soft quota used for alerting only. For regular volumes, valid values are in the range 50GiB to 100TiB.
+     * For large volumes, valid values are in the range 100TiB to 500TiB, and on an exceptional basis, from to 2400GiB to 2400TiB.
+     * For extra large volumes, valid values are in the range 2400GiB to 7200TiB. Values expressed in bytes as multiples of 1 GiB.
+     */
     usageThreshold?: number;
     /** Set of export policy rules */
     exportPolicy?: VolumePatchPropertiesExportPolicy;
@@ -1298,22 +1644,6 @@ export interface ReplicationStatus {
     errorMessage?: string;
 }
 export declare function replicationStatusDeserializer(item: any): ReplicationStatus;
-/** Status of the volume replication relationship */
-export declare enum KnownVolumeReplicationRelationshipStatus {
-    /** Idle */
-    Idle = "Idle",
-    /** Transferring */
-    Transferring = "Transferring"
-}
-/**
- * Status of the volume replication relationship \
- * {@link KnownVolumeReplicationRelationshipStatus} can be used interchangeably with VolumeReplicationRelationshipStatus,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **Idle** \
- * **Transferring**
- */
-export type VolumeReplicationRelationshipStatus = string;
 /** Body for the list replications endpoint. If supplied, the body will be used as a filter for example to exclude deleted replications. If omitted, the endpoint returns all replications */
 export interface ListReplicationsRequest {
     /** Exclude Replications filter. 'None' returns all replications, 'Deleted' excludes deleted replications. Default is 'None' */
@@ -1936,107 +2266,1909 @@ export interface _BackupVaultsList {
 export declare function _backupVaultsListDeserializer(item: any): _BackupVaultsList;
 export declare function backupVaultArraySerializer(result: Array<BackupVault>): any[];
 export declare function backupVaultArrayDeserializer(result: Array<BackupVault>): any[];
-/** Information regarding regionInfo Item. */
-export interface RegionInfoResource extends ProxyResource {
-    /** regionInfo properties */
-    properties?: RegionInfo;
+/** Bucket resource */
+export interface Bucket extends ProxyResource {
+    /** Bucket properties */
+    properties?: BucketProperties;
+}
+export declare function bucketSerializer(item: Bucket): any;
+export declare function bucketDeserializer(item: any): Bucket;
+/** Bucket resource properties */
+export interface BucketProperties {
+    /** The volume path mounted inside the bucket. The default is the root path '/' if no value is provided when the bucket is created. */
+    path?: string;
+    /** File System user having access to volume data. For Unix, this is the user's uid and gid. For Windows, this is the user's username. Note that the Unix and Windows user details are mutually exclusive, meaning one or other must be supplied, but not both. */
+    fileSystemUser?: FileSystemUser;
+    /** Provisioning state of the resource */
+    readonly provisioningState?: NetAppProvisioningState;
+    /**
+     * 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.
+     */
+    readonly status?: CredentialsStatus;
+    /** Properties of the server managing the lifecycle of volume buckets */
+    server?: BucketServerProperties;
+    /** Access permissions for the bucket. Either ReadOnly or ReadWrite. The default is ReadOnly if no value is provided during bucket creation. */
+    permissions?: BucketPermissions;
+    /**
+     * Specifies the Azure Key Vault settings. These are used when
+     * a) retrieving the bucket server certificate, and
+     * b) storing the bucket credentials
+     *
+     * Notes:
+     *
+     * 1. If a bucket certificate was previously provided directly using the certificateObject property, it is possible to subsequently use the Azure Key Vault for certificate management by using these 'akvDetails' properties. However, once Azure Key Vault is configured, it is no longer possible to provide the certificate directly via the certificateObject property.
+     * 2. These properties are mutually exclusive with the server.certificateObject property.
+     */
+    akvDetails?: AzureKeyVaultDetails;
+}
+export declare function bucketPropertiesSerializer(item: BucketProperties): any;
+export declare function bucketPropertiesDeserializer(item: any): BucketProperties;
+/** File System user having access to volume data. For Unix, this is the user's uid and gid. For Windows, this is the user's username. Note that the Unix and Windows user details are mutually exclusive, meaning one or other must be supplied, but not both. */
+export interface FileSystemUser {
+    /** The effective NFS User ID and Group ID when accessing the volume data. */
+    nfsUser?: NfsUser;
+    /** The effective CIFS username when accessing the volume data. */
+    cifsUser?: CifsUser;
+}
+export declare function fileSystemUserSerializer(item: FileSystemUser): any;
+export declare function fileSystemUserDeserializer(item: any): FileSystemUser;
+/** The effective NFS User ID and Group ID when accessing the volume data. */
+export interface NfsUser {
+    /** The NFS user's UID */
+    userId?: number;
+    /** The NFS user's GID */
+    groupId?: number;
+}
+export declare function nfsUserSerializer(item: NfsUser): any;
+export declare function nfsUserDeserializer(item: any): NfsUser;
+/** The effective CIFS username when accessing the volume data. */
+export interface CifsUser {
+    /** The CIFS user's username */
+    username?: string;
 }
-export declare function regionInfoResourceDeserializer(item: any): RegionInfoResource;
-/** Provides region specific information. */
-export interface RegionInfo {
-    /** Provides storage to network proximity information in the region. */
-    storageToNetworkProximity?: RegionStorageToNetworkProximity;
-    /** Provides logical availability zone mappings for the subscription for a region. */
-    availabilityZoneMappings?: RegionInfoAvailabilityZoneMappingsItem[];
+export declare function cifsUserSerializer(item: CifsUser): any;
+export declare function cifsUserDeserializer(item: any): CifsUser;
+/**
+ * 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 declare enum KnownCredentialsStatus {
+    /** Access and Secret key pair have not been generated. */
+    NoCredentialsSet = "NoCredentialsSet",
+    /** Access and Secret key pair have expired. */
+    CredentialsExpired = "CredentialsExpired",
+    /** The certificate has been installed on the bucket server and the bucket credentials are unexpired. */
+    Active = "Active"
 }
-export declare function regionInfoDeserializer(item: any): RegionInfo;
-/** Provides storage to network proximity information in the region. */
-export declare enum KnownRegionStorageToNetworkProximity {
-    /** Basic network connectivity. */
-    Default = "Default",
-    /** Standard T1 network connectivity. */
-    T1 = "T1",
-    /** Standard T2 network connectivity. */
-    T2 = "T2",
-    /** Standard AcrossT2 network connectivity. */
-    AcrossT2 = "AcrossT2",
-    /** Standard T1 and T2 network connectivity. */
-    T1AndT2 = "T1AndT2",
-    /** Standard T1 and AcrossT2 network connectivity. */
-    T1AndAcrossT2 = "T1AndAcrossT2",
-    /** Standard T2 and AcrossT2 network connectivity. */
-    T2AndAcrossT2 = "T2AndAcrossT2",
-    /** Standard T1, T2 and AcrossT2 network connectivity. */
-    T1AndT2AndAcrossT2 = "T1AndT2AndAcrossT2"
+/**
+ * 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. \
+ * {@link KnownCredentialsStatus} can be used interchangeably with CredentialsStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **NoCredentialsSet**: Access and Secret key pair have not been generated. \
+ * **CredentialsExpired**: Access and Secret key pair have expired. \
+ * **Active**: The certificate has been installed on the bucket server and the bucket credentials are unexpired.
+ */
+export type CredentialsStatus = string;
+/** Properties of the server managing the lifecycle of volume buckets */
+export interface BucketServerProperties {
+    /** The host part of the bucket URL, resolving to the bucket IP address and allowed by the server certificate. */
+    fqdn?: string;
+    /** Certificate Common Name taken from the certificate installed on the bucket server */
+    readonly certificateCommonName?: string;
+    /** The bucket server's certificate expiry date. */
+    readonly certificateExpiryDate?: Date;
+    /** The bucket server's IPv4 address */
+    readonly ipAddress?: string;
+    /**
+     * The base64-encoded contents of a PEM file, which includes both the bucket server's certificate and private key. It is generated by the end user and allows the user to access volume data in a read-only manner.
+     * Note: This is only used when Azure Key Vault is not configured. This property is mutually exclusive with the Azure Key Vault 'akv' properties.
+     */
+    certificateObject?: string;
+    /**
+     * Action to take when there is a certificate conflict.
+     * Possible values include: 'Update', 'Fail'
+     */
+    onCertificateConflictAction?: OnCertificateConflictAction;
 }
+export declare function bucketServerPropertiesSerializer(item: BucketServerProperties): any;
+export declare function bucketServerPropertiesDeserializer(item: any): BucketServerProperties;
 /**
- * Provides storage to network proximity information in the region. \
- * {@link KnownRegionStorageToNetworkProximity} can be used interchangeably with RegionStorageToNetworkProximity,
+ * 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 declare enum 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. */
+    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. */
+    Fail = "Fail"
+}
+/**
+ * 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. \
+ * {@link KnownOnCertificateConflictAction} can be used interchangeably with OnCertificateConflictAction,
  *  this enum contains the known values that the service supports.
  * ### Known values supported by the service
- * **Default**: Basic network connectivity. \
- * **T1**: Standard T1 network connectivity. \
- * **T2**: Standard T2 network connectivity. \
- * **AcrossT2**: Standard AcrossT2 network connectivity. \
- * **T1AndT2**: Standard T1 and T2 network connectivity. \
- * **T1AndAcrossT2**: Standard T1 and AcrossT2 network connectivity. \
- * **T2AndAcrossT2**: Standard T2 and AcrossT2 network connectivity. \
- * **T1AndT2AndAcrossT2**: Standard T1, T2 and AcrossT2 network connectivity.
+ * **Update**: 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. \
+ * **Fail**: Fail the operation if a conflict occurs, meaning the bucket operation will fail, and the existing certificate will continue to be in use.
  */
-export type RegionStorageToNetworkProximity = string;
-export declare function regionInfoAvailabilityZoneMappingsItemArrayDeserializer(result: Array<RegionInfoAvailabilityZoneMappingsItem>): any[];
-/** model interface RegionInfoAvailabilityZoneMappingsItem */
-export interface RegionInfoAvailabilityZoneMappingsItem {
-    /** Logical availability zone. */
-    availabilityZone?: string;
-    /** Available availability zone */
-    isAvailable?: boolean;
+export type OnCertificateConflictAction = string;
+/** Access permissions for the bucket. Either ReadOnly or ReadWrite. The default is ReadOnly if no value is provided during bucket creation. */
+export declare enum KnownBucketPermissions {
+    /** Read-only access to bucket. */
+    ReadOnly = "ReadOnly",
+    /** Read-write access to bucket. */
+    ReadWrite = "ReadWrite"
 }
-export declare function regionInfoAvailabilityZoneMappingsItemDeserializer(item: any): RegionInfoAvailabilityZoneMappingsItem;
-/** List of regionInfo resources */
-export interface _RegionInfosList {
-    /** The RegionInfoResource items on this page */
-    value: RegionInfoResource[];
+/**
+ * Access permissions for the bucket. Either ReadOnly or ReadWrite. The default is ReadOnly if no value is provided during bucket creation. \
+ * {@link KnownBucketPermissions} can be used interchangeably with BucketPermissions,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ReadOnly**: Read-only access to bucket. \
+ * **ReadWrite**: Read-write access to bucket.
+ */
+export type BucketPermissions = string;
+/**
+ * Specifies the Azure Key Vault settings. These are used when
+ * a) retrieving the bucket server certificate, and
+ * b) storing the bucket credentials
+ *
+ * Notes:
+ *
+ * 1. If a bucket certificate was previously provided directly using the certificateObject property, it is possible to subsequently use the Azure Key Vault for certificate management by using these 'akvDetails' properties. However, once Azure Key Vault is configured, it is no longer possible to provide the certificate directly via the certificateObject property.
+ *
+ * 2. These properties are mutually exclusive with the server.certificateObject property.
+ */
+export interface AzureKeyVaultDetails {
+    /** Specifies the Azure Key Vault settings for retrieving the bucket server certificate. */
+    certificateAkvDetails?: CertificateAkvDetails;
+    /** Specifies the Azure Key Vault settings for storing the bucket credentials. */
+    credentialsAkvDetails?: CredentialsAkvDetails;
+}
+export declare function azureKeyVaultDetailsSerializer(item: AzureKeyVaultDetails): any;
+export declare function azureKeyVaultDetailsDeserializer(item: any): AzureKeyVaultDetails;
+/** Specifies the Azure Key Vault settings for retrieving the bucket server certificate. */
+export interface CertificateAkvDetails {
+    /** The base URI of the Azure Key Vault that is used when retrieving the bucket certificate. */
+    certificateKeyVaultUri?: string;
+    /** The name of the bucket server certificate stored in the Azure Key Vault. */
+    certificateName?: string;
+}
+export declare function certificateAkvDetailsSerializer(item: CertificateAkvDetails): any;
+export declare function certificateAkvDetailsDeserializer(item: any): CertificateAkvDetails;
+/** Specifies the Azure Key Vault settings for storing the bucket credentials. */
+export interface CredentialsAkvDetails {
+    /** The base URI of the Azure Key Vault that is used when storing the bucket credentials. */
+    credentialsKeyVaultUri?: string;
+    /**
+     * The name of the secret stored in Azure Key Vault. The associated key pair has the following structure:
+     *
+     * {
+     * "access_key_id": "<REDACTED>",
+     * "secret_access_key": "<REDACTED>"
+     * }
+     */
+    secretName?: string;
+}
+export declare function credentialsAkvDetailsSerializer(item: CredentialsAkvDetails): any;
+export declare function credentialsAkvDetailsDeserializer(item: any): CredentialsAkvDetails;
+/** Bucket resource */
+export interface BucketPatch extends ProxyResource {
+    /** Bucket properties */
+    properties?: BucketPatchProperties;
+}
+export declare function bucketPatchSerializer(item: BucketPatch): any;
+/** Bucket resource properties for a Patch operation */
+export interface BucketPatchProperties {
+    /** File System user having access to volume data. For Unix, this is the user's uid and gid. For Windows, this is the user's username. Note that the Unix and Windows user details are mutually exclusive, meaning one or other must be supplied, but not both. */
+    fileSystemUser?: FileSystemUser;
+    /** Provisioning state of the resource */
+    readonly provisioningState?: NetAppProvisioningState;
+    /** Properties of the server managing the lifecycle of volume buckets */
+    server?: BucketServerPatchProperties;
+    /** Access permissions for the bucket. Either ReadOnly or ReadWrite. */
+    permissions?: BucketPatchPermissions;
+    /**
+     * Specifies the Azure Key Vault settings. These are used when
+     * a) retrieving the bucket server certificate, and
+     * b) storing the bucket credentials
+     *
+     * Notes:
+     *
+     * 1. If a bucket certificate was previously provided directly using the certificateObject property, it is possible to subsequently use the Azure Key Vault for certificate management by using these 'akvDetails' properties. However, once Azure Key Vault is configured, it is no longer possible to provide the certificate directly via the certificateObject property.
+     * 2. These properties are mutually exclusive with the server.certificateObject property.
+     */
+    akvDetails?: AzureKeyVaultDetails;
+}
+export declare function bucketPatchPropertiesSerializer(item: BucketPatchProperties): any;
+/** Properties of the server managing the lifecycle of volume buckets */
+export interface BucketServerPatchProperties {
+    /** The host part of the bucket URL, resolving to the bucket IP address and allowed by the server certificate. */
+    fqdn?: string;
+    /**
+     * The base64-encoded contents of a PEM file, which includes both the bucket server's certificate and private key. It is generated by the end user and allows the user to access volume data in a read-only manner.
+     * Note: This is only used when Azure Key Vault is not configured. This property is mutually exclusive with the Azure Key Vault 'akv' properties.
+     */
+    certificateObject?: string;
+    /**
+     * Action to take when there is a certificate conflict.
+     * Possible values include: 'Update', 'Fail'
+     */
+    onCertificateConflictAction?: OnCertificateConflictAction;
+}
+export declare function bucketServerPatchPropertiesSerializer(item: BucketServerPatchProperties): any;
+/** Access permissions for the bucket. Either ReadOnly or ReadWrite. */
+export declare enum KnownBucketPatchPermissions {
+    /** Read-only access to bucket. */
+    ReadOnly = "ReadOnly",
+    /** Read-write access to bucket. */
+    ReadWrite = "ReadWrite"
+}
+/**
+ * Access permissions for the bucket. Either ReadOnly or ReadWrite. \
+ * {@link KnownBucketPatchPermissions} can be used interchangeably with BucketPatchPermissions,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ReadOnly**: Read-only access to bucket. \
+ * **ReadWrite**: Read-write access to bucket.
+ */
+export type BucketPatchPermissions = string;
+/** List of volume bucket resources */
+export interface _BucketList {
+    /** The Bucket items on this page */
+    value: Bucket[];
     /** The link to the next page of items */
     nextLink?: string;
 }
-export declare function _regionInfosListDeserializer(item: any): _RegionInfosList;
-export declare function regionInfoResourceArrayDeserializer(result: Array<RegionInfoResource>): any[];
-/** NetApp account resource */
-export interface NetAppAccount extends TrackedResource {
-    /** NetApp Account properties */
-    properties?: AccountProperties;
+export declare function _bucketListDeserializer(item: any): _BucketList;
+export declare function bucketArraySerializer(result: Array<Bucket>): any[];
+export declare function bucketArrayDeserializer(result: Array<Bucket>): any[];
+/** The bucket's Access and Secret key pair Expiry Time expressed as the number of days from now. */
+export interface BucketCredentialsExpiry {
+    /** The number of days from now until the newly generated Access and Secret key pair will expire. */
+    keyPairExpiryDays?: number;
+}
+export declare function bucketCredentialsExpirySerializer(item: BucketCredentialsExpiry): any;
+/** Bucket Access Key, Secret Key, and Expiry date and time of the key pair */
+export interface BucketGenerateCredentials {
+    /** The Access Key that is required along with the Secret Key to access the bucket. */
+    readonly accessKey?: string;
+    /** The Secret Key that is required along with the Access Key to access the bucket. */
+    readonly secretKey?: string;
+    /** The bucket's Access and Secret key pair expiry date and time (in UTC). */
+    readonly keyPairExpiry?: Date;
+}
+export declare function bucketGenerateCredentialsDeserializer(item: any): BucketGenerateCredentials;
+/** Cache resource */
+export interface Cache extends TrackedResource {
+    /** Cache properties */
+    properties: CacheProperties;
     /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
     readonly etag?: string;
-    /** The managed service identities assigned to this resource. */
-    identity?: ManagedServiceIdentity;
+    /** The availability zones. */
+    zones?: string[];
 }
-export declare function netAppAccountSerializer(item: NetAppAccount): any;
-export declare function netAppAccountDeserializer(item: any): NetAppAccount;
-/** NetApp account properties */
-export interface AccountProperties {
+export declare function cacheSerializer(item: Cache): any;
+export declare function cacheDeserializer(item: any): Cache;
+/** Cache resource properties */
+export interface CacheProperties {
+    /** The file path of the Cache. */
+    filePath: string;
+    /** Maximum storage quota allowed for a file system in bytes. Valid values are in the range 50GiB to 1PiB. Values expressed in bytes as multiples of 1GiB. */
+    size: number;
+    /** Set of export policy rules */
+    exportPolicy?: CachePropertiesExportPolicy;
+    /** Set of supported protocol types, which include NFSv3, NFSv4 and SMB protocol */
+    protocolTypes?: ProtocolTypes[];
     /** Azure lifecycle management */
-    readonly provisioningState?: string;
-    /** Active Directories */
-    activeDirectories?: ActiveDirectory[];
-    /** Encryption settings */
-    encryption?: AccountEncryption;
-    /** Shows the status of disableShowmount for all volumes under the subscription, null equals false */
-    readonly disableShowmount?: boolean | null;
-    /** Domain for NFSv4 user ID mapping. This property will be set for all NetApp accounts in the subscription and region and only affect non ldap NFSv4 volumes. */
-    nfsV4IDDomain?: string | null;
-    /** MultiAD Status for the account */
-    readonly multiAdStatus?: MultiAdStatus;
+    readonly provisioningState?: CacheProvisioningState;
+    /** Azure NetApp Files Cache lifecycle management */
+    readonly cacheState?: CacheLifeCycleState;
+    /** The Azure Resource URI for a delegated cache subnet that will be used to allocate data IPs. */
+    cacheSubnetResourceId: string;
+    /** The Azure Resource URI for a delegated subnet that will be used for ANF Intercluster Interface IP addresses. */
+    peeringSubnetResourceId: string;
+    /** List of mount targets that can be used to mount this cache */
+    readonly mountTargets?: CacheMountTargetProperties[];
+    /** Describe if a cache is Kerberos enabled. */
+    kerberos?: KerberosState;
+    /** SMB information for the cache */
+    smbSettings?: SmbSettings;
+    /** Maximum throughput in MiB/s that can be achieved by this cache volume and this will be accepted as input only for manual qosType cache */
+    throughputMibps?: number;
+    /** Actual throughput in MiB/s for auto qosType volumes calculated based on size and serviceLevel */
+    readonly actualThroughputMibps?: number;
+    /** Source of key used to encrypt data in the cache. Applicable if NetApp account has encryption.keySource = 'Microsoft.KeyVault'. Possible values (case-insensitive) are: 'Microsoft.NetApp, Microsoft.KeyVault' */
+    encryptionKeySource: EncryptionKeySource;
+    /** The resource ID of private endpoint for KeyVault. It must reside in the same VNET as the volume. Only applicable if encryptionKeySource = 'Microsoft.KeyVault'. */
+    keyVaultPrivateEndpointResourceId?: string;
+    /** Maximum number of files allowed. */
+    readonly maximumNumberOfFiles?: number;
+    /** Specifies if the cache is encryption or not. */
+    readonly encryption?: EncryptionState;
+    /** Language supported for volume. */
+    readonly language?: VolumeLanguage;
+    /** Specifies whether LDAP is enabled or not for flexcache volume. */
+    ldap?: LdapState;
+    /** Specifies the type of LDAP server for flexcache volume. */
+    ldapServerType?: LdapServerType;
+    /** Origin cluster information */
+    originClusterInformation: OriginClusterInformation;
+    /** Flag indicating whether a CIFS change notification is enabled for the cache. */
+    cifsChangeNotifications?: CifsChangeNotifyState;
+    /** Flag indicating whether the global file lock is enabled for the cache. */
+    globalFileLocking?: GlobalFileLockingState;
+    /** Flag indicating whether writeback is enabled for the cache. */
+    writeBack?: EnableWriteBackState;
+}
+export declare function cachePropertiesSerializer(item: CacheProperties): any;
+export declare function cachePropertiesDeserializer(item: any): CacheProperties;
+/** Set of export policy rules */
+export interface CachePropertiesExportPolicy {
+    /** Export policy rule */
+    rules?: ExportPolicyRule[];
 }
-export declare function accountPropertiesSerializer(item: AccountProperties): any;
-export declare function accountPropertiesDeserializer(item: any): AccountProperties;
-export declare function activeDirectoryArraySerializer(result: Array<ActiveDirectory>): any[];
-export declare function activeDirectoryArrayDeserializer(result: Array<ActiveDirectory>): any[];
-/** Active Directory */
-export interface ActiveDirectory {
-    /** Id of the Active Directory */
-    activeDirectoryId?: string | null;
-    /** A domain user account with permission to create machine accounts */
+export declare function cachePropertiesExportPolicySerializer(item: CachePropertiesExportPolicy): any;
+export declare function cachePropertiesExportPolicyDeserializer(item: any): CachePropertiesExportPolicy;
+/** Set of supported protocol types, which include NFSv3, NFSv4 and SMB protocol */
+export declare enum KnownProtocolTypes {
+    /** NFSv3 protocol type */
+    NFSv3 = "NFSv3",
+    /** NFSv4 protocol type */
+    NFSv4 = "NFSv4",
+    /** SMB protocol type */
+    SMB = "SMB"
+}
+/**
+ * Set of supported protocol types, which include NFSv3, NFSv4 and SMB protocol \
+ * {@link KnownProtocolTypes} can be used interchangeably with ProtocolTypes,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **NFSv3**: NFSv3 protocol type \
+ * **NFSv4**: NFSv4 protocol type \
+ * **SMB**: SMB protocol type
+ */
+export type ProtocolTypes = string;
+/** Azure lifecycle management */
+export declare enum KnownCacheProvisioningState {
+    /** The resource is being created. */
+    Creating = "Creating",
+    /** The resource is being updated. */
+    Updating = "Updating",
+    /** The resource is being deleted. */
+    Deleting = "Deleting",
+    /** The resource is in a failed state. */
+    Failed = "Failed",
+    /** The resource is succeeded. */
+    Succeeded = "Succeeded",
+    /** Resource creation was canceled. */
+    Canceled = "Canceled"
+}
+/**
+ * Azure lifecycle management \
+ * {@link KnownCacheProvisioningState} can be used interchangeably with CacheProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Creating**: The resource is being created. \
+ * **Updating**: The resource is being updated. \
+ * **Deleting**: The resource is being deleted. \
+ * **Failed**: The resource is in a failed state. \
+ * **Succeeded**: The resource is succeeded. \
+ * **Canceled**: Resource creation was canceled.
+ */
+export type CacheProvisioningState = string;
+/** Azure NetApp Files Cache lifecycle management */
+export declare enum KnownCacheLifeCycleState {
+    /** Cluster peering offer has been sent. */
+    ClusterPeeringOfferSent = "ClusterPeeringOfferSent",
+    /** VServer peering offer has been sent. */
+    VserverPeeringOfferSent = "VserverPeeringOfferSent",
+    /** Cache creation in progress. */
+    Creating = "Creating",
+    /** Cache creation succeeded and is available for use. */
+    Succeeded = "Succeeded",
+    /** Cache is in a failed state */
+    Failed = "Failed"
+}
+/**
+ * Azure NetApp Files Cache lifecycle management \
+ * {@link KnownCacheLifeCycleState} can be used interchangeably with CacheLifeCycleState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ClusterPeeringOfferSent**: Cluster peering offer has been sent. \
+ * **VserverPeeringOfferSent**: VServer peering offer has been sent. \
+ * **Creating**: Cache creation in progress. \
+ * **Succeeded**: Cache creation succeeded and is available for use. \
+ * **Failed**: Cache is in a failed state
+ */
+export type CacheLifeCycleState = string;
+export declare function cacheMountTargetPropertiesArrayDeserializer(result: Array<CacheMountTargetProperties>): any[];
+/** Contains all the information needed to mount a cache */
+export interface CacheMountTargetProperties {
+    /** UUID v4 used to identify the MountTarget */
+    readonly mountTargetId?: string;
+    /** The mount target's IPv4 address, used to mount the cache. */
+    readonly ipAddress?: string;
+    /** The SMB server's Fully Qualified Domain Name, FQDN */
+    readonly smbServerFqdn?: string;
+}
+export declare function cacheMountTargetPropertiesDeserializer(item: any): CacheMountTargetProperties;
+/** Describe if a cache is Kerberos enabled. */
+export declare enum KnownKerberosState {
+    /** Kerberos is disabled */
+    Disabled = "Disabled",
+    /** Kerberos is enabled */
+    Enabled = "Enabled"
+}
+/**
+ * Describe if a cache is Kerberos enabled. \
+ * {@link KnownKerberosState} can be used interchangeably with KerberosState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Disabled**: Kerberos is disabled \
+ * **Enabled**: Kerberos is enabled
+ */
+export type KerberosState = string;
+/** SMB settings for the cache */
+export interface SmbSettings {
+    /** Enables encryption for in-flight smb3 data. Only applicable for SMB/DualProtocol cache. */
+    smbEncryption?: SmbEncryptionState;
+    /** Enables access-based enumeration share property for SMB Shares. Only applicable for SMB/DualProtocol volume */
+    smbAccessBasedEnumeration?: SmbAccessBasedEnumeration;
+    /** Enables non-browsable property for SMB Shares. Only applicable for SMB/DualProtocol volume */
+    smbNonBrowsable?: SmbNonBrowsable;
+}
+export declare function smbSettingsSerializer(item: SmbSettings): any;
+export declare function smbSettingsDeserializer(item: any): SmbSettings;
+/** Enables encryption for in-flight smb3 data. Only applicable for SMB/DualProtocol cache */
+export declare enum KnownSmbEncryptionState {
+    /** SMB encryption is disabled */
+    Disabled = "Disabled",
+    /** SMB encryption is enabled */
+    Enabled = "Enabled"
+}
+/**
+ * Enables encryption for in-flight smb3 data. Only applicable for SMB/DualProtocol cache \
+ * {@link KnownSmbEncryptionState} can be used interchangeably with SmbEncryptionState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Disabled**: SMB encryption is disabled \
+ * **Enabled**: SMB encryption is enabled
+ */
+export type SmbEncryptionState = string;
+/** Specifies if the cache is encryption or not. */
+export declare enum KnownEncryptionState {
+    /** Encryption is disabled */
+    Disabled = "Disabled",
+    /** Encryption is enabled */
+    Enabled = "Enabled"
+}
+/**
+ * Specifies if the cache is encryption or not. \
+ * {@link KnownEncryptionState} can be used interchangeably with EncryptionState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Disabled**: Encryption is disabled \
+ * **Enabled**: Encryption is enabled
+ */
+export type EncryptionState = string;
+/** Specifies whether LDAP is enabled or not. */
+export declare enum KnownLdapState {
+    /** ldap is disabled. */
+    Disabled = "Disabled",
+    /** ldap is enabled */
+    Enabled = "Enabled"
+}
+/**
+ * Specifies whether LDAP is enabled or not. \
+ * {@link KnownLdapState} can be used interchangeably with LdapState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Disabled**: ldap is disabled. \
+ * **Enabled**: ldap is enabled
+ */
+export type LdapState = string;
+/** Stores the origin cluster information associated to a cache. */
+export interface OriginClusterInformation {
+    /** ONTAP cluster name of external cluster hosting the origin volume */
+    peerClusterName: string;
+    /** ONTAP Intercluster LIF IP addresses. One IP address per cluster node is required */
+    peerAddresses: string[];
+    /** External Vserver (SVM) name  name of the SVM hosting the origin volume */
+    peerVserverName: string;
+    /** External origin volume name associated to this cache */
+    peerVolumeName: string;
+}
+export declare function originClusterInformationSerializer(item: OriginClusterInformation): any;
+export declare function originClusterInformationDeserializer(item: any): OriginClusterInformation;
+/** Flag indicating whether a CIFS change notification is enabled for the cache. */
+export declare enum KnownCifsChangeNotifyState {
+    /** CIFS change notification is disabled */
+    Disabled = "Disabled",
+    /** CIFS change notification is enabled */
+    Enabled = "Enabled"
+}
+/**
+ * Flag indicating whether a CIFS change notification is enabled for the cache. \
+ * {@link KnownCifsChangeNotifyState} can be used interchangeably with CifsChangeNotifyState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Disabled**: CIFS change notification is disabled \
+ * **Enabled**: CIFS change notification is enabled
+ */
+export type CifsChangeNotifyState = string;
+/** Flag indicating whether the global file lock is enabled for the cache. */
+export declare enum KnownGlobalFileLockingState {
+    /** Global file locking is disabled */
+    Disabled = "Disabled",
+    /** Global file locking is enabled */
+    Enabled = "Enabled"
+}
+/**
+ * Flag indicating whether the global file lock is enabled for the cache. \
+ * {@link KnownGlobalFileLockingState} can be used interchangeably with GlobalFileLockingState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Disabled**: Global file locking is disabled \
+ * **Enabled**: Global file locking is enabled
+ */
+export type GlobalFileLockingState = string;
+/** Flag indicating whether writeback is enabled for the cache. */
+export declare enum KnownEnableWriteBackState {
+    /** Writeback cache is disabled */
+    Disabled = "Disabled",
+    /** Writeback cache is enabled */
+    Enabled = "Enabled"
+}
+/**
+ * Flag indicating whether writeback is enabled for the cache. \
+ * {@link KnownEnableWriteBackState} can be used interchangeably with EnableWriteBackState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Disabled**: Writeback cache is disabled \
+ * **Enabled**: Writeback cache is enabled
+ */
+export type EnableWriteBackState = string;
+/** The type used for update operations of the Cache. */
+export interface CacheUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: CacheUpdateProperties;
+}
+export declare function cacheUpdateSerializer(item: CacheUpdate): any;
+/** The updatable properties of the Cache. */
+export interface CacheUpdateProperties {
+    /** Maximum storage quota allowed for a file system in bytes. Valid values are in the range 50GiB to 1PiB. Values expressed in bytes as multiples of 1GiB. */
+    size?: number;
+    /** Set of export policy rules */
+    exportPolicy?: CachePropertiesExportPolicy;
+    /** Set of supported protocol types, which include NFSv3, NFSv4 and SMB protocol */
+    protocolTypes?: ProtocolTypes[];
+    /** SMB information for the cache */
+    smbSettings?: SmbSettings;
+    /** Maximum throughput in MiB/s that can be achieved by this cache volume and this will be accepted as input only for manual qosType cache */
+    throughputMibps?: number;
+    /** The resource ID of private endpoint for KeyVault. It must reside in the same VNET as the volume. Only applicable if encryptionKeySource = 'Microsoft.KeyVault'. */
+    keyVaultPrivateEndpointResourceId?: string;
+    /** Flag indicating whether a CIFS change notification is enabled for the cache. */
+    cifsChangeNotifications?: CifsChangeNotifyState;
+    /** Flag indicating whether writeback is enabled for the cache. */
+    writeBack?: EnableWriteBackState;
+}
+export declare function cacheUpdatePropertiesSerializer(item: CacheUpdateProperties): any;
+/** List of Cache resources */
+export interface _CacheList {
+    /** The Cache items on this page */
+    value: Cache[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _cacheListDeserializer(item: any): _CacheList;
+export declare function cacheArraySerializer(result: Array<Cache>): any[];
+export declare function cacheArrayDeserializer(result: Array<Cache>): any[];
+/** The response containing peering passphrases and commands for cluster and vserver peering. */
+export interface PeeringPassphrases {
+    /** The cluster peering command. */
+    clusterPeeringCommand: string;
+    /** The cluster peering passphrase. */
+    clusterPeeringPassphrase: string;
+    /** The vserver peering command. */
+    vserverPeeringCommand: string;
+    /** Warnings that are critical for the cluster peering and vserver peering processes. */
+    readonly criticalWarning?: string;
+}
+export declare function peeringPassphrasesDeserializer(item: any): PeeringPassphrases;
+/** NetApp elastic account resource */
+export interface ElasticAccount extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticAccountProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+}
+export declare function elasticAccountSerializer(item: ElasticAccount): any;
+export declare function elasticAccountDeserializer(item: any): ElasticAccount;
+/** NetApp elastic account properties */
+export interface ElasticAccountProperties {
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+    /** Encryption settings */
+    encryption?: ElasticEncryption;
+}
+export declare function elasticAccountPropertiesSerializer(item: ElasticAccountProperties): any;
+export declare function elasticAccountPropertiesDeserializer(item: any): ElasticAccountProperties;
+/** Encryption settings */
+export interface ElasticEncryption {
+    /** The encryption keySource (provider). Possible values (case-insensitive): Microsoft.NetApp, Microsoft.KeyVault */
+    keySource?: KeySource;
+    /** Properties provided by KeyVault. Applicable if keySource is 'Microsoft.KeyVault'. */
+    keyVaultProperties?: ElasticKeyVaultProperties;
+    /** Identity used to authenticate to KeyVault. Applicable if keySource is 'Microsoft.KeyVault'. */
+    identity?: ElasticEncryptionIdentity;
+}
+export declare function elasticEncryptionSerializer(item: ElasticEncryption): any;
+export declare function elasticEncryptionDeserializer(item: any): ElasticEncryption;
+/** The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.NetApp, Microsoft.KeyVault */
+export declare enum KnownKeySource {
+    /** Microsoft-managed key encryption */
+    MicrosoftNetApp = "Microsoft.NetApp",
+    /** Customer-managed key encryption */
+    MicrosoftKeyVault = "Microsoft.KeyVault"
+}
+/**
+ * The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.NetApp, Microsoft.KeyVault \
+ * {@link KnownKeySource} can be used interchangeably with KeySource,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Microsoft.NetApp**: Microsoft-managed key encryption \
+ * **Microsoft.KeyVault**: Customer-managed key encryption
+ */
+export type KeySource = string;
+/** Properties of key vault. */
+export interface ElasticKeyVaultProperties {
+    /** The Uri of KeyVault. */
+    keyVaultUri?: string;
+    /** The name of KeyVault key. */
+    keyName?: string;
+    /** The resource ID of KeyVault. */
+    keyVaultResourceId?: string;
+    /** Status of the KeyVault connection. */
+    readonly status?: ElasticKeyVaultStatus;
+}
+export declare function elasticKeyVaultPropertiesSerializer(item: ElasticKeyVaultProperties): any;
+export declare function elasticKeyVaultPropertiesDeserializer(item: any): ElasticKeyVaultProperties;
+/** KeyVault status */
+export declare enum KnownElasticKeyVaultStatus {
+    /** KeyVault connection created but not in use */
+    Created = "Created",
+    /** KeyVault connection in use by SMB Volume */
+    InUse = "InUse",
+    /** KeyVault connection Deleted */
+    Deleted = "Deleted",
+    /** Error with the KeyVault connection */
+    Error = "Error",
+    /** KeyVault connection Updating */
+    Updating = "Updating"
+}
+/**
+ * KeyVault status \
+ * {@link KnownElasticKeyVaultStatus} can be used interchangeably with ElasticKeyVaultStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Created**: KeyVault connection created but not in use \
+ * **InUse**: KeyVault connection in use by SMB Volume \
+ * **Deleted**: KeyVault connection Deleted \
+ * **Error**: Error with the KeyVault connection \
+ * **Updating**: KeyVault connection Updating
+ */
+export type ElasticKeyVaultStatus = string;
+/** Identity used to authenticate with key vault. */
+export interface ElasticEncryptionIdentity {
+    /** The principal ID (object ID) of the identity used to authenticate with key vault. Read-only. */
+    readonly principalId?: string;
+    /** The ARM resource identifier of the user assigned identity used to authenticate with key vault. Applicable if identity.type has 'UserAssigned'. It should match key of identity.userAssignedIdentities. */
+    userAssignedIdentity?: string;
+    /** ClientId of the multi-tenant Entra ID Application. Used to access cross-tenant keyvaults. */
+    federatedClientId?: string;
+}
+export declare function elasticEncryptionIdentitySerializer(item: ElasticEncryptionIdentity): any;
+export declare function elasticEncryptionIdentityDeserializer(item: any): ElasticEncryptionIdentity;
+/** Managed service identity (system assigned and/or user assigned identities) */
+export interface ManagedServiceIdentity {
+    /** The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity. */
+    readonly principalId?: string;
+    /** The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity. */
+    readonly tenantId?: string;
+    /** The type of managed identity assigned to this resource. */
+    type: ManagedServiceIdentityType;
+    /** The identities assigned to this resource by the user. */
+    userAssignedIdentities?: Record<string, UserAssignedIdentity | null>;
+}
+export declare function managedServiceIdentitySerializer(item: ManagedServiceIdentity): any;
+export declare function managedServiceIdentityDeserializer(item: any): ManagedServiceIdentity;
+/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
+export declare enum KnownManagedServiceIdentityType {
+    /** No managed identity. */
+    None = "None",
+    /** System assigned managed identity. */
+    SystemAssigned = "SystemAssigned",
+    /** User assigned managed identity. */
+    UserAssigned = "UserAssigned",
+    /** System and user assigned managed identity. */
+    SystemAssignedUserAssigned = "SystemAssigned,UserAssigned"
+}
+/**
+ * Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). \
+ * {@link KnownManagedServiceIdentityType} can be used interchangeably with ManagedServiceIdentityType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None**: No managed identity. \
+ * **SystemAssigned**: System assigned managed identity. \
+ * **UserAssigned**: User assigned managed identity. \
+ * **SystemAssigned,UserAssigned**: System and user assigned managed identity.
+ */
+export type ManagedServiceIdentityType = string;
+/** User assigned identity properties */
+export interface UserAssignedIdentity {
+    /** The principal ID of the assigned identity. */
+    readonly principalId?: string;
+    /** The client ID of the assigned identity. */
+    readonly clientId?: string;
+}
+export declare function userAssignedIdentitySerializer(item: UserAssignedIdentity): any;
+export declare function userAssignedIdentityDeserializer(item: any): UserAssignedIdentity;
+/** The type used for update operations of the ElasticAccount. */
+export interface ElasticAccountUpdate {
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticAccountUpdateProperties;
+}
+export declare function elasticAccountUpdateSerializer(item: ElasticAccountUpdate): any;
+/** The updatable properties of the ElasticAccount. */
+export interface ElasticAccountUpdateProperties {
+    /** Encryption settings */
+    encryption?: ElasticEncryption;
+}
+export declare function elasticAccountUpdatePropertiesSerializer(item: ElasticAccountUpdateProperties): any;
+/** The response of a ElasticAccount list operation. */
+export interface _ElasticAccountListResult {
+    /** The ElasticAccount items on this page */
+    value: ElasticAccount[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticAccountListResultDeserializer(item: any): _ElasticAccountListResult;
+export declare function elasticAccountArraySerializer(result: Array<ElasticAccount>): any[];
+export declare function elasticAccountArrayDeserializer(result: Array<ElasticAccount>): any[];
+/** NetApp Elastic Capacity Pool resource */
+export interface ElasticCapacityPool extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticCapacityPoolProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+    /** The availability zones. */
+    zones?: string[];
+}
+export declare function elasticCapacityPoolSerializer(item: ElasticCapacityPool): any;
+export declare function elasticCapacityPoolDeserializer(item: any): ElasticCapacityPool;
+/** Elastic capacity pool properties */
+export interface ElasticCapacityPoolProperties {
+    /** Provisioned size of the pool (in bytes). For zoneRedundant service level pool, value must be in the range 1TiB to 16TiB or 1TiB to 128TiB for supported region. Values expressed in bytes as multiples of 1TiB till 16TiB and in multiples of 8TiB from 24TiB to 128TiB. Pool size can't be shrunk once it is created. */
+    size: number;
+    /** The service level of the elastic capacity pool */
+    serviceLevel: ElasticServiceLevel;
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+    /** Encryption settings */
+    encryption?: ElasticEncryptionConfiguration;
+    /** Total throughput of the pool in MiB/s */
+    readonly totalThroughputMibps?: number;
+    /** The Azure Resource URI for a delegated subnet. Must have the delegation Microsoft.NetApp/elasticVolumes, this is used by all the volumes within the pool */
+    subnetResourceId: string;
+    /** Indicates the current zone of the pool. This can be changed for zoneRedundant service level pool with the changeZone action */
+    readonly currentZone?: string;
+    /** Current availability status of the resource. */
+    readonly availabilityStatus?: ElasticResourceAvailabilityStatus;
+    /** The Azure Resource URI for an Active Directory configuration. This is used by all the SMB volumes within the pool */
+    activeDirectoryConfigResourceId?: string;
+}
+export declare function elasticCapacityPoolPropertiesSerializer(item: ElasticCapacityPoolProperties): any;
+export declare function elasticCapacityPoolPropertiesDeserializer(item: any): ElasticCapacityPoolProperties;
+/** Service level for elastic capacity pool */
+export declare enum KnownElasticServiceLevel {
+    /** Zone redundant storage service level. */
+    ZoneRedundant = "ZoneRedundant"
+}
+/**
+ * Service level for elastic capacity pool \
+ * {@link KnownElasticServiceLevel} can be used interchangeably with ElasticServiceLevel,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ZoneRedundant**: Zone redundant storage service level.
+ */
+export type ElasticServiceLevel = string;
+/** CMK Encryption Configuration */
+export interface ElasticEncryptionConfiguration {
+    /** Pool Encryption Key Source. */
+    elasticPoolEncryptionKeySource: ElasticPoolEncryptionKeySource;
+    /** The resource ID of private endpoint for KeyVault. It must reside in the same VNET as the volume. Only applicable if encryptionKeySource = 'Microsoft.KeyVault'. */
+    keyVaultPrivateEndpointResourceId: string;
+}
+export declare function elasticEncryptionConfigurationSerializer(item: ElasticEncryptionConfiguration): any;
+export declare function elasticEncryptionConfigurationDeserializer(item: any): ElasticEncryptionConfiguration;
+/** Pool Encryption Key Source. */
+export declare enum KnownElasticPoolEncryptionKeySource {
+    /** Represents the encryption key source of Elastic pool is Microsoft.NetApp */
+    NetApp = "NetApp",
+    /** Represents the encryption key source of Elastic pool is Microsoft.KeyVault */
+    KeyVault = "KeyVault"
+}
+/**
+ * Pool Encryption Key Source. \
+ * {@link KnownElasticPoolEncryptionKeySource} can be used interchangeably with ElasticPoolEncryptionKeySource,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **NetApp**: Represents the encryption key source of Elastic pool is Microsoft.NetApp \
+ * **KeyVault**: Represents the encryption key source of Elastic pool is Microsoft.KeyVault
+ */
+export type ElasticPoolEncryptionKeySource = string;
+/** Current availability status of the resource. */
+export declare enum KnownElasticResourceAvailabilityStatus {
+    /** The resource is currently Online and accessible */
+    Online = "Online",
+    /** The resource is currently Offline and not accessible */
+    Offline = "Offline"
+}
+/**
+ * Current availability status of the resource. \
+ * {@link KnownElasticResourceAvailabilityStatus} can be used interchangeably with ElasticResourceAvailabilityStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Online**: The resource is currently Online and accessible \
+ * **Offline**: The resource is currently Offline and not accessible
+ */
+export type ElasticResourceAvailabilityStatus = string;
+/** The type used for update operations of the ElasticCapacityPool. */
+export interface ElasticCapacityPoolUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticCapacityPoolUpdateProperties;
+}
+export declare function elasticCapacityPoolUpdateSerializer(item: ElasticCapacityPoolUpdate): any;
+/** The updatable properties of the ElasticCapacityPool. */
+export interface ElasticCapacityPoolUpdateProperties {
+    /** Provisioned size of the pool (in bytes). For zoneRedundant service level pool, value must be in the range 1TiB to 16TiB or 1TiB to 128TiB for supported region. Values expressed in bytes as multiples of 1TiB till 16TiB and in multiples of 8TiB from 24TiB to 128TiB. Pool size can't be shrunk once it is created. */
+    size?: number;
+    /** Encryption settings */
+    encryption?: ElasticEncryptionConfiguration;
+    /** The Azure Resource URI for an Active Directory configuration. This is used by all the SMB volumes within the pool */
+    activeDirectoryConfigResourceId?: string;
+}
+export declare function elasticCapacityPoolUpdatePropertiesSerializer(item: ElasticCapacityPoolUpdateProperties): any;
+/** The response of a ElasticCapacityPool list operation. */
+export interface _ElasticCapacityPoolListResult {
+    /** The ElasticCapacityPool items on this page */
+    value: ElasticCapacityPool[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticCapacityPoolListResultDeserializer(item: any): _ElasticCapacityPoolListResult;
+export declare function elasticCapacityPoolArraySerializer(result: Array<ElasticCapacityPool>): any[];
+export declare function elasticCapacityPoolArrayDeserializer(result: Array<ElasticCapacityPool>): any[];
+/** Changes the zone for the Zone Redundant elastic capacity pool */
+export interface ChangeZoneRequest {
+    /** Availability zone to move Zone Redundant elastic capacity pool to */
+    newZone: string;
+}
+export declare function changeZoneRequestSerializer(item: ChangeZoneRequest): any;
+/** File path availability request content - availability is based on the elastic volume filePath within the given elastic capacityPool. */
+export interface CheckElasticVolumeFilePathAvailabilityRequest {
+    /** A unique file path for the volume. Used when creating mount targets. This needs to be unique within the elastic capacity pool. */
+    filePath: string;
+}
+export declare function checkElasticVolumeFilePathAvailabilityRequestSerializer(item: CheckElasticVolumeFilePathAvailabilityRequest): any;
+/** Information regarding availability of a resource. */
+export interface CheckElasticResourceAvailabilityResponse {
+    /** True indicates name is valid and available. False indicates the name is invalid, unavailable, or both. */
+    isAvailable?: CheckElasticResourceAvailabilityStatus;
+    /** Invalid indicates the name provided does not match Azure NetApp Files naming requirements. AlreadyExists indicates that the name is already in use and is therefore unavailable. */
+    reason?: CheckElasticResourceAvailabilityReason;
+    /** If reason == invalid, provide the user with the reason why the given name is invalid, and provide the resource naming requirements so that the user can select a valid name. If reason == AlreadyExists, explain that resource name is already in use, and direct them to select a different name. */
+    message?: string;
+}
+export declare function checkElasticResourceAvailabilityResponseDeserializer(item: any): CheckElasticResourceAvailabilityResponse;
+/** Availability status */
+export declare enum KnownCheckElasticResourceAvailabilityStatus {
+    /** Value indicating the name is valid and available */
+    True = "True",
+    /** Value indicating the the name is invalid, unavailable, or both. */
+    False = "False"
+}
+/**
+ * Availability status \
+ * {@link KnownCheckElasticResourceAvailabilityStatus} can be used interchangeably with CheckElasticResourceAvailabilityStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **True**: Value indicating the name is valid and available \
+ * **False**: Value indicating the the name is invalid, unavailable, or both.
+ */
+export type CheckElasticResourceAvailabilityStatus = string;
+/** Availability reason */
+export declare enum KnownCheckElasticResourceAvailabilityReason {
+    /** Value indicating the name provided does not match Azure NetApp Files naming requirements */
+    Invalid = "Invalid",
+    /** Value indicating the name is already in use and is therefore unavailable */
+    AlreadyExists = "AlreadyExists"
+}
+/**
+ * Availability reason \
+ * {@link KnownCheckElasticResourceAvailabilityReason} can be used interchangeably with CheckElasticResourceAvailabilityReason,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Invalid**: Value indicating the name provided does not match Azure NetApp Files naming requirements \
+ * **AlreadyExists**: Value indicating the name is already in use and is therefore unavailable
+ */
+export type CheckElasticResourceAvailabilityReason = string;
+/** NetApp Elastic Volume resource */
+export interface ElasticVolume extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticVolumeProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+    /** The availability zones. */
+    zones?: string[];
+}
+export declare function elasticVolumeSerializer(item: ElasticVolume): any;
+export declare function elasticVolumeDeserializer(item: any): ElasticVolume;
+/** Elastic Volume properties */
+export interface ElasticVolumeProperties {
+    /** A unique file path for the volume. Used when creating mount targets. This needs to be unique within the elastic capacity pool. */
+    filePath: string;
+    /** Maximum size allowed for a volume in bytes. Valid values are in the range 1GiB to 16TiB. Values expressed in bytes as multiples of 1 GiB. */
+    size: number;
+    /** Set of export policy rules */
+    exportPolicy?: ElasticExportPolicy;
+    /** Set of support protocol types for the elastic volume */
+    protocolTypes: ElasticProtocolType[];
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+    /** Current availability status of the resource. */
+    readonly availabilityStatus?: ElasticResourceAvailabilityStatus;
+    /** Resource identifier used to identify the Elastic Snapshot. */
+    snapshotResourceId?: string;
+    /** List of mount targets that can be used to mount this volume */
+    readonly mountTargets?: ElasticMountTargetProperties[];
+    /** Data protection configuration option for the volume, including snapshot policies and backup. */
+    dataProtection?: ElasticVolumeDataProtectionProperties;
+    /** Controls the visibility of the volume's read-only snapshot directory, which provides access to each of the volume's snapshots. */
+    snapshotDirectoryVisibility?: SnapshotDirectoryVisibility;
+    /** SMB Properties */
+    smbProperties?: ElasticSmbProperties;
+    /** Resource identifier used to identify the Elastic Backup. */
+    backupResourceId?: string;
+    /** The current state of the restoration process. */
+    readonly restorationState?: ElasticVolumeRestorationState;
+}
+export declare function elasticVolumePropertiesSerializer(item: ElasticVolumeProperties): any;
+export declare function elasticVolumePropertiesDeserializer(item: any): ElasticVolumeProperties;
+/** Set of export policy rules */
+export interface ElasticExportPolicy {
+    /** Export policy rule */
+    rules?: ElasticExportPolicyRule[];
+}
+export declare function elasticExportPolicySerializer(item: ElasticExportPolicy): any;
+export declare function elasticExportPolicyDeserializer(item: any): ElasticExportPolicy;
+export declare function elasticExportPolicyRuleArraySerializer(result: Array<ElasticExportPolicyRule>): any[];
+export declare function elasticExportPolicyRuleArrayDeserializer(result: Array<ElasticExportPolicyRule>): any[];
+/** Elastic Volume Export Policy Rule */
+export interface ElasticExportPolicyRule {
+    /** Controls the priority of the export policy rule. When connecting to the volume the rule with the lowest index that applies to the connecting client is used */
+    ruleIndex?: number;
+    /** Specifies the Unix file access level for the volume. It encompasses both read-only and read-write permissions. Additionally, NoAccess can be set to block all access to the volume */
+    unixAccessRule?: ElasticUnixAccessRule;
+    /** Allows clients to access the volume with the NFSv3 protocol. Enable only for NFSv3 type volumes */
+    nfsv3?: ElasticNfsv3Access;
+    /** Allows clients to access the volume with at least NFSv4.1 protocol. */
+    nfsv4?: ElasticNfsv4Access;
+    /** Client ingress specification for the export policy as list of IPv4 CIDRs, IPv4 host addresses and host names. */
+    allowedClients?: string[];
+    /** Indicates whether root access to the volume is granted to clients affected by this rule */
+    rootAccess?: ElasticRootAccess;
+}
+export declare function elasticExportPolicyRuleSerializer(item: ElasticExportPolicyRule): any;
+export declare function elasticExportPolicyRuleDeserializer(item: any): ElasticExportPolicyRule;
+/** Unix access rule */
+export declare enum KnownElasticUnixAccessRule {
+    /** Clients connecting with this rule will only have read access to the volume */
+    ReadOnly = "ReadOnly",
+    /** Clients connecting with this rule will have full read and write access to the volume */
+    ReadWrite = "ReadWrite",
+    /** Clients connecting with this rule will have no access to the volume */
+    NoAccess = "NoAccess"
+}
+/**
+ * Unix access rule \
+ * {@link KnownElasticUnixAccessRule} can be used interchangeably with ElasticUnixAccessRule,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ReadOnly**: Clients connecting with this rule will only have read access to the volume \
+ * **ReadWrite**: Clients connecting with this rule will have full read and write access to the volume \
+ * **NoAccess**: Clients connecting with this rule will have no access to the volume
+ */
+export type ElasticUnixAccessRule = string;
+/** NFSv3 access */
+export declare enum KnownElasticNfsv3Access {
+    /** Clients can connect to the volume using the NFSv3 protocol. */
+    Enabled = "Enabled",
+    /** Clients can't connect to the volume using the NFSv3 protocol. */
+    Disabled = "Disabled"
+}
+/**
+ * NFSv3 access \
+ * {@link KnownElasticNfsv3Access} can be used interchangeably with ElasticNfsv3Access,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Clients can connect to the volume using the NFSv3 protocol. \
+ * **Disabled**: Clients can't connect to the volume using the NFSv3 protocol.
+ */
+export type ElasticNfsv3Access = string;
+/** NFSv4 access */
+export declare enum KnownElasticNfsv4Access {
+    /** Clients can connect to the volume using the NFSv4 protocol. */
+    Enabled = "Enabled",
+    /** Clients can't connect to the volume using the NFSv4 protocol. */
+    Disabled = "Disabled"
+}
+/**
+ * NFSv4 access \
+ * {@link KnownElasticNfsv4Access} can be used interchangeably with ElasticNfsv4Access,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Clients can connect to the volume using the NFSv4 protocol. \
+ * **Disabled**: Clients can't connect to the volume using the NFSv4 protocol.
+ */
+export type ElasticNfsv4Access = string;
+/** Root access */
+export declare enum KnownElasticRootAccess {
+    /** Root user access is enabled for clients affected by this rule */
+    Enabled = "Enabled",
+    /** Root user access is disabled for clients affected by this rule */
+    Disabled = "Disabled"
+}
+/**
+ * Root access \
+ * {@link KnownElasticRootAccess} can be used interchangeably with ElasticRootAccess,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Root user access is enabled for clients affected by this rule \
+ * **Disabled**: Root user access is disabled for clients affected by this rule
+ */
+export type ElasticRootAccess = string;
+/** Protocol types for elastic volume */
+export declare enum KnownElasticProtocolType {
+    /** NFSv3 protocol type */
+    NFSv3 = "NFSv3",
+    /** NFSv4 protocol type */
+    NFSv4 = "NFSv4",
+    /** SMB/CIFS protocol type */
+    SMB = "SMB"
+}
+/**
+ * Protocol types for elastic volume \
+ * {@link KnownElasticProtocolType} can be used interchangeably with ElasticProtocolType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **NFSv3**: NFSv3 protocol type \
+ * **NFSv4**: NFSv4 protocol type \
+ * **SMB**: SMB\/CIFS protocol type
+ */
+export type ElasticProtocolType = string;
+export declare function elasticMountTargetPropertiesArrayDeserializer(result: Array<ElasticMountTargetProperties>): any[];
+/** Contains all the information needed to mount an elastic volume */
+export interface ElasticMountTargetProperties {
+    /** The mount target's IPv4 address, used to mount the volume */
+    readonly ipAddress?: string;
+    /** The SMB server's Fully Qualified Domain Name, FQDN */
+    readonly smbServerFqdn?: string;
+}
+export declare function elasticMountTargetPropertiesDeserializer(item: any): ElasticMountTargetProperties;
+/** Data protection configuration option for the volume, including snapshot policies and backup. */
+export interface ElasticVolumeDataProtectionProperties {
+    /** Used to apply a snapshot policy to a volume. */
+    snapshot?: ElasticVolumeSnapshotProperties;
+    /** Used to configure backups on an elastic volume. */
+    backup?: ElasticVolumeBackupProperties;
+}
+export declare function elasticVolumeDataProtectionPropertiesSerializer(item: ElasticVolumeDataProtectionProperties): any;
+export declare function elasticVolumeDataProtectionPropertiesDeserializer(item: any): ElasticVolumeDataProtectionProperties;
+/** Elastic Volume Snapshot Properties */
+export interface ElasticVolumeSnapshotProperties {
+    /** Snapshot Policy ResourceId */
+    snapshotPolicyResourceId?: string;
+}
+export declare function elasticVolumeSnapshotPropertiesSerializer(item: ElasticVolumeSnapshotProperties): any;
+export declare function elasticVolumeSnapshotPropertiesDeserializer(item: any): ElasticVolumeSnapshotProperties;
+/** Elastic Volume Backup Properties */
+export interface ElasticVolumeBackupProperties {
+    /** ResourceId used to identify Elastic Backup Policy */
+    elasticBackupPolicyResourceId?: string;
+    /** The property to decide policy is enforced or not on the volume */
+    policyEnforcement?: ElasticVolumePolicyEnforcement;
+    /** ResourceId used to identify Elastic Backup Vault */
+    elasticBackupVaultResourceId?: string;
+}
+export declare function elasticVolumeBackupPropertiesSerializer(item: ElasticVolumeBackupProperties): any;
+export declare function elasticVolumeBackupPropertiesDeserializer(item: any): ElasticVolumeBackupProperties;
+/** Policy enforcement */
+export declare enum KnownElasticVolumePolicyEnforcement {
+    /** Value indicating the policy is enforced on the volume. */
+    Enforced = "Enforced",
+    /** Value indicating the policy is not enforced on the volume. */
+    NotEnforced = "NotEnforced"
+}
+/**
+ * Policy enforcement \
+ * {@link KnownElasticVolumePolicyEnforcement} can be used interchangeably with ElasticVolumePolicyEnforcement,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enforced**: Value indicating the policy is enforced on the volume. \
+ * **NotEnforced**: Value indicating the policy is not enforced on the volume.
+ */
+export type ElasticVolumePolicyEnforcement = string;
+/** Controls the visibility of the Elastic Volume's read-only snapshot directory, which provides access to each of the volume's snapshots. */
+export declare enum KnownSnapshotDirectoryVisibility {
+    /** Value indicating the read-only snapshot directory is not visible */
+    Hidden = "Hidden",
+    /** Value indicating the read-only snapshot directory is visible */
+    Visible = "Visible"
+}
+/**
+ * Controls the visibility of the Elastic Volume's read-only snapshot directory, which provides access to each of the volume's snapshots. \
+ * {@link KnownSnapshotDirectoryVisibility} can be used interchangeably with SnapshotDirectoryVisibility,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Hidden**: Value indicating the read-only snapshot directory is not visible \
+ * **Visible**: Value indicating the read-only snapshot directory is visible
+ */
+export type SnapshotDirectoryVisibility = string;
+/** SMB Properties */
+export interface ElasticSmbProperties {
+    /** Used to enable or disable encryption for in-flight SMB data volume. This flag can be modified during Elastic volume update operation as well. Only applicable for SMB protocol Elastic volumes. */
+    smbEncryption?: ElasticSmbEncryption;
+}
+export declare function elasticSmbPropertiesSerializer(item: ElasticSmbProperties): any;
+export declare function elasticSmbPropertiesDeserializer(item: any): ElasticSmbProperties;
+/** SMB encryption */
+export declare enum KnownElasticSmbEncryption {
+    /** Value indicating the SMB encryption is enabled */
+    Enabled = "Enabled",
+    /** Value indicating the SMB encryption is disabled */
+    Disabled = "Disabled"
+}
+/**
+ * SMB encryption \
+ * {@link KnownElasticSmbEncryption} can be used interchangeably with ElasticSmbEncryption,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Value indicating the SMB encryption is enabled \
+ * **Disabled**: Value indicating the SMB encryption is disabled
+ */
+export type ElasticSmbEncryption = string;
+/** The current state of the restoration process. */
+export declare enum KnownElasticVolumeRestorationState {
+    /** Value indicating that the volume is currently restoring. */
+    Restoring = "Restoring",
+    /** Value indicating that the volume is restored. */
+    Restored = "Restored",
+    /** Value indicating that the volume restore has failed. */
+    Failed = "Failed"
+}
+/**
+ * The current state of the restoration process. \
+ * {@link KnownElasticVolumeRestorationState} can be used interchangeably with ElasticVolumeRestorationState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Restoring**: Value indicating that the volume is currently restoring. \
+ * **Restored**: Value indicating that the volume is restored. \
+ * **Failed**: Value indicating that the volume restore has failed.
+ */
+export type ElasticVolumeRestorationState = string;
+/** The type used for update operations of the ElasticVolume. */
+export interface ElasticVolumeUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticVolumeUpdateProperties;
+}
+export declare function elasticVolumeUpdateSerializer(item: ElasticVolumeUpdate): any;
+/** The updatable properties of the ElasticVolume. */
+export interface ElasticVolumeUpdateProperties {
+    /** Maximum size allowed for a volume in bytes. Valid values are in the range 1GiB to 16TiB. Values expressed in bytes as multiples of 1 GiB. */
+    size?: number;
+    /** Set of export policy rules */
+    exportPolicy?: ElasticExportPolicy;
+    /** Data protection configuration option for the volume, including snapshot policies and backup. */
+    dataProtection?: ElasticVolumeDataProtectionPatchProperties;
+    /** Controls the visibility of the volume's read-only snapshot directory, which provides access to each of the volume's snapshots. */
+    snapshotDirectoryVisibility?: SnapshotDirectoryVisibility;
+    /** SMB Properties */
+    smbProperties?: ElasticSmbPatchProperties;
+}
+export declare function elasticVolumeUpdatePropertiesSerializer(item: ElasticVolumeUpdateProperties): any;
+/** Data protection configuration option for updating the volume, including snapshot policies and backup. */
+export interface ElasticVolumeDataProtectionPatchProperties {
+    /** Used to apply a snapshot policy to a volume. */
+    snapshot?: ElasticVolumeSnapshotProperties;
+    /** Used to configure backups on an elastic volume. */
+    backup?: ElasticVolumeBackupProperties;
+}
+export declare function elasticVolumeDataProtectionPatchPropertiesSerializer(item: ElasticVolumeDataProtectionPatchProperties): any;
+/** SMB Patch Properties */
+export interface ElasticSmbPatchProperties {
+    /** Used to enable or disable encryption for in-flight SMB data volume. This flag can be modified during Elastic volume update operation as well. Only applicable for SMB protocol Elastic volumes. */
+    smbEncryption?: ElasticSmbEncryption;
+}
+export declare function elasticSmbPatchPropertiesSerializer(item: ElasticSmbPatchProperties): any;
+/** The response of a ElasticVolume list operation. */
+export interface _ElasticVolumeListResult {
+    /** The ElasticVolume items on this page */
+    value: ElasticVolume[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticVolumeListResultDeserializer(item: any): _ElasticVolumeListResult;
+export declare function elasticVolumeArraySerializer(result: Array<ElasticVolume>): any[];
+export declare function elasticVolumeArrayDeserializer(result: Array<ElasticVolume>): any[];
+/** Reverts the elastic volume to the specified snapshot. */
+export interface ElasticVolumeRevert {
+    /** Resource identifier used to identify the Elastic Snapshot. */
+    snapshotResourceId?: string;
+}
+export declare function elasticVolumeRevertSerializer(item: ElasticVolumeRevert): any;
+/** NetApp Elastic Snapshot under an Elastic Volume */
+export interface ElasticSnapshot extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticSnapshotProperties;
+}
+export declare function elasticSnapshotSerializer(item: ElasticSnapshot): any;
+export declare function elasticSnapshotDeserializer(item: any): ElasticSnapshot;
+/** Elastic Snapshot properties */
+export interface ElasticSnapshotProperties {
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+}
+export declare function elasticSnapshotPropertiesSerializer(item: ElasticSnapshotProperties): any;
+export declare function elasticSnapshotPropertiesDeserializer(item: any): ElasticSnapshotProperties;
+/** The response of a ElasticSnapshot list operation. */
+export interface _ElasticSnapshotListResult {
+    /** The ElasticSnapshot items on this page */
+    value: ElasticSnapshot[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticSnapshotListResultDeserializer(item: any): _ElasticSnapshotListResult;
+export declare function elasticSnapshotArraySerializer(result: Array<ElasticSnapshot>): any[];
+export declare function elasticSnapshotArrayDeserializer(result: Array<ElasticSnapshot>): any[];
+/** NetApp Elastic Snapshot Policy under an Elastic Account */
+export interface ElasticSnapshotPolicy extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticSnapshotPolicyProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function elasticSnapshotPolicySerializer(item: ElasticSnapshotPolicy): any;
+export declare function elasticSnapshotPolicyDeserializer(item: any): ElasticSnapshotPolicy;
+/** Elastic Snapshot policy properties */
+export interface ElasticSnapshotPolicyProperties {
+    /** Schedule for hourly snapshots */
+    hourlySchedule?: ElasticSnapshotPolicyHourlySchedule;
+    /** Schedule for daily snapshots */
+    dailySchedule?: ElasticSnapshotPolicyDailySchedule;
+    /** Schedule for weekly snapshots */
+    weeklySchedule?: ElasticSnapshotPolicyWeeklySchedule;
+    /** Schedule for monthly snapshots */
+    monthlySchedule?: ElasticSnapshotPolicyMonthlySchedule;
+    /** Configures if the snapshot policy is enabled on the volumes connected to the policy. */
+    policyStatus?: PolicyStatus;
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+}
+export declare function elasticSnapshotPolicyPropertiesSerializer(item: ElasticSnapshotPolicyProperties): any;
+export declare function elasticSnapshotPolicyPropertiesDeserializer(item: any): ElasticSnapshotPolicyProperties;
+/** Hourly Schedule properties used to create NetApp snapshot policy */
+export interface ElasticSnapshotPolicyHourlySchedule {
+    /** Hourly snapshot count to keep */
+    snapshotsToKeep?: number;
+    /** Indicates which minute snapshot should be taken */
+    minute?: number;
+}
+export declare function elasticSnapshotPolicyHourlyScheduleSerializer(item: ElasticSnapshotPolicyHourlySchedule): any;
+export declare function elasticSnapshotPolicyHourlyScheduleDeserializer(item: any): ElasticSnapshotPolicyHourlySchedule;
+/** Daily Schedule properties used to create NetApp snapshot policy */
+export interface ElasticSnapshotPolicyDailySchedule {
+    /** Daily snapshot count to keep */
+    snapshotsToKeep?: number;
+    /** Indicates which hour in UTC timezone a snapshot should be taken */
+    hour?: number;
+    /** Indicates which minute snapshot should be taken */
+    minute?: number;
+}
+export declare function elasticSnapshotPolicyDailyScheduleSerializer(item: ElasticSnapshotPolicyDailySchedule): any;
+export declare function elasticSnapshotPolicyDailyScheduleDeserializer(item: any): ElasticSnapshotPolicyDailySchedule;
+/** Weekly Schedule properties used to create NetApp snapshot policy */
+export interface ElasticSnapshotPolicyWeeklySchedule {
+    /** Weekly snapshot count to keep */
+    snapshotsToKeep?: number;
+    /** Indicates which weekday(s) snapshot(s) should be taken, accepts a list of week day names in english */
+    days?: DayOfWeek[];
+    /** Indicates which hour in UTC timezone a snapshot should be taken */
+    hour?: number;
+    /** Indicates which minute snapshot should be taken */
+    minute?: number;
+}
+export declare function elasticSnapshotPolicyWeeklyScheduleSerializer(item: ElasticSnapshotPolicyWeeklySchedule): any;
+export declare function elasticSnapshotPolicyWeeklyScheduleDeserializer(item: any): ElasticSnapshotPolicyWeeklySchedule;
+/** Day of the week */
+export declare enum KnownDayOfWeek {
+    /** Take a snapshot each Sunday */
+    Sunday = "Sunday",
+    /** Take a snapshot each Monday */
+    Monday = "Monday",
+    /** Take a snapshot each Tuesday */
+    Tuesday = "Tuesday",
+    /** Take a snapshot each Wednesday */
+    Wednesday = "Wednesday",
+    /** Take a snapshot each Thursday */
+    Thursday = "Thursday",
+    /** Take a snapshot each Friday */
+    Friday = "Friday",
+    /** Take a snapshot each Saturday */
+    Saturday = "Saturday"
+}
+/**
+ * Day of the week \
+ * {@link KnownDayOfWeek} can be used interchangeably with DayOfWeek,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Sunday**: Take a snapshot each Sunday \
+ * **Monday**: Take a snapshot each Monday \
+ * **Tuesday**: Take a snapshot each Tuesday \
+ * **Wednesday**: Take a snapshot each Wednesday \
+ * **Thursday**: Take a snapshot each Thursday \
+ * **Friday**: Take a snapshot each Friday \
+ * **Saturday**: Take a snapshot each Saturday
+ */
+export type DayOfWeek = string;
+/** Monthly Schedule properties used to create NetApp snapshot policy */
+export interface ElasticSnapshotPolicyMonthlySchedule {
+    /** Monthly snapshot count to keep */
+    snapshotsToKeep?: number;
+    /** Indicates which days of the month snapshot (1-31) should be taken, accepts a list of integers */
+    daysOfMonth?: number[];
+    /** Indicates which hour in UTC timezone a snapshot should be taken */
+    hour?: number;
+    /** Indicates which minute snapshot should be taken */
+    minute?: number;
+}
+export declare function elasticSnapshotPolicyMonthlyScheduleSerializer(item: ElasticSnapshotPolicyMonthlySchedule): any;
+export declare function elasticSnapshotPolicyMonthlyScheduleDeserializer(item: any): ElasticSnapshotPolicyMonthlySchedule;
+/** Policy status */
+export declare enum KnownPolicyStatus {
+    /** Value indicating the policy is enabled */
+    Enabled = "Enabled",
+    /** Value indicating the policy is disabled */
+    Disabled = "Disabled"
+}
+/**
+ * Policy status \
+ * {@link KnownPolicyStatus} can be used interchangeably with PolicyStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Value indicating the policy is enabled \
+ * **Disabled**: Value indicating the policy is disabled
+ */
+export type PolicyStatus = string;
+/** The type used for update operations of the ElasticSnapshotPolicy. */
+export interface ElasticSnapshotPolicyUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticSnapshotPolicyUpdateProperties;
+}
+export declare function elasticSnapshotPolicyUpdateSerializer(item: ElasticSnapshotPolicyUpdate): any;
+/** The updatable properties of the ElasticSnapshotPolicy. */
+export interface ElasticSnapshotPolicyUpdateProperties {
+    /** Schedule for hourly snapshots */
+    hourlySchedule?: ElasticSnapshotPolicyHourlySchedule;
+    /** Schedule for daily snapshots */
+    dailySchedule?: ElasticSnapshotPolicyDailySchedule;
+    /** Schedule for weekly snapshots */
+    weeklySchedule?: ElasticSnapshotPolicyWeeklySchedule;
+    /** Schedule for monthly snapshots */
+    monthlySchedule?: ElasticSnapshotPolicyMonthlySchedule;
+    /** Configures if the snapshot policy is enabled on the volumes connected to the policy. */
+    policyStatus?: PolicyStatus;
+}
+export declare function elasticSnapshotPolicyUpdatePropertiesSerializer(item: ElasticSnapshotPolicyUpdateProperties): any;
+/** The response of a ElasticSnapshotPolicy list operation. */
+export interface _ElasticSnapshotPolicyListResult {
+    /** The ElasticSnapshotPolicy items on this page */
+    value: ElasticSnapshotPolicy[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticSnapshotPolicyListResultDeserializer(item: any): _ElasticSnapshotPolicyListResult;
+export declare function elasticSnapshotPolicyArraySerializer(result: Array<ElasticSnapshotPolicy>): any[];
+export declare function elasticSnapshotPolicyArrayDeserializer(result: Array<ElasticSnapshotPolicy>): any[];
+/** Elastic Volumes associated with Elastic Snapshot Policy */
+export interface _ElasticSnapshotPolicyVolumeList {
+    /** The ElasticVolume items on this page */
+    value: ElasticVolume[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticSnapshotPolicyVolumeListDeserializer(item: any): _ElasticSnapshotPolicyVolumeList;
+/** NetApp elastic backup vault resource */
+export interface ElasticBackupVault extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticBackupVaultProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function elasticBackupVaultSerializer(item: ElasticBackupVault): any;
+export declare function elasticBackupVaultDeserializer(item: any): ElasticBackupVault;
+/** Elastic Backup Vault properties */
+export interface ElasticBackupVaultProperties {
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+}
+export declare function elasticBackupVaultPropertiesSerializer(item: ElasticBackupVaultProperties): any;
+export declare function elasticBackupVaultPropertiesDeserializer(item: any): ElasticBackupVaultProperties;
+/** The type used for update operations of the ElasticBackupVault. */
+export interface ElasticBackupVaultUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+}
+export declare function elasticBackupVaultUpdateSerializer(item: ElasticBackupVaultUpdate): any;
+/** The response of a ElasticBackupVault list operation. */
+export interface _ElasticBackupVaultListResult {
+    /** The ElasticBackupVault items on this page */
+    value: ElasticBackupVault[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticBackupVaultListResultDeserializer(item: any): _ElasticBackupVaultListResult;
+export declare function elasticBackupVaultArraySerializer(result: Array<ElasticBackupVault>): any[];
+export declare function elasticBackupVaultArrayDeserializer(result: Array<ElasticBackupVault>): any[];
+/** NetApp Elastic Backup Policy resource */
+export interface ElasticBackupPolicy extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticBackupPolicyProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function elasticBackupPolicySerializer(item: ElasticBackupPolicy): any;
+export declare function elasticBackupPolicyDeserializer(item: any): ElasticBackupPolicy;
+/** Elastic Backup Policy properties */
+export interface ElasticBackupPolicyProperties {
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+    /** Daily backups count to keep */
+    dailyBackupsToKeep?: number;
+    /** Weekly backups count to keep */
+    weeklyBackupsToKeep?: number;
+    /** Monthly backups count to keep */
+    monthlyBackupsToKeep?: number;
+    /** The number of volumes currently using this Backup Policy. */
+    readonly assignedVolumesCount?: number;
+    /** The property to identify whether Backup Policy is enabled or not */
+    policyState?: ElasticBackupPolicyState;
+}
+export declare function elasticBackupPolicyPropertiesSerializer(item: ElasticBackupPolicyProperties): any;
+export declare function elasticBackupPolicyPropertiesDeserializer(item: any): ElasticBackupPolicyProperties;
+/** Elastic Backup Policy state */
+export declare enum KnownElasticBackupPolicyState {
+    /** Value indicating the policy is enabled */
+    Enabled = "Enabled",
+    /** Value indicating the policy is disabled */
+    Disabled = "Disabled"
+}
+/**
+ * Elastic Backup Policy state \
+ * {@link KnownElasticBackupPolicyState} can be used interchangeably with ElasticBackupPolicyState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Value indicating the policy is enabled \
+ * **Disabled**: Value indicating the policy is disabled
+ */
+export type ElasticBackupPolicyState = string;
+/** The type used for update operations of the ElasticBackupPolicy. */
+export interface ElasticBackupPolicyUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticBackupPolicyUpdateProperties;
+}
+export declare function elasticBackupPolicyUpdateSerializer(item: ElasticBackupPolicyUpdate): any;
+/** The updatable properties of the ElasticBackupPolicy. */
+export interface ElasticBackupPolicyUpdateProperties {
+    /** Daily backups count to keep */
+    dailyBackupsToKeep?: number;
+    /** Weekly backups count to keep */
+    weeklyBackupsToKeep?: number;
+    /** Monthly backups count to keep */
+    monthlyBackupsToKeep?: number;
+    /** The property to identify whether Backup Policy is enabled or not */
+    policyState?: ElasticBackupPolicyState;
+}
+export declare function elasticBackupPolicyUpdatePropertiesSerializer(item: ElasticBackupPolicyUpdateProperties): any;
+/** The response of a ElasticBackupPolicy list operation. */
+export interface _ElasticBackupPolicyListResult {
+    /** The ElasticBackupPolicy items on this page */
+    value: ElasticBackupPolicy[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticBackupPolicyListResultDeserializer(item: any): _ElasticBackupPolicyListResult;
+export declare function elasticBackupPolicyArraySerializer(result: Array<ElasticBackupPolicy>): any[];
+export declare function elasticBackupPolicyArrayDeserializer(result: Array<ElasticBackupPolicy>): any[];
+/** NetApp Elastic Backup under an elastic Backup Vault */
+export interface ElasticBackup extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ElasticBackupProperties;
+}
+export declare function elasticBackupSerializer(item: ElasticBackup): any;
+export declare function elasticBackupDeserializer(item: any): ElasticBackup;
+/** Elastic Backup properties */
+export interface ElasticBackupProperties {
+    /** The creation date of the backup */
+    readonly creationDate?: Date;
+    /** The snapshot creation date of the backup */
+    readonly snapshotCreationDate?: Date;
+    /** The completion date of the backup */
+    readonly completionDate?: Date;
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+    /** Size of backup in bytes */
+    readonly size?: number;
+    /** Label for backup */
+    label?: string;
+    /** Type of backup Manual or Scheduled */
+    readonly backupType?: ElasticBackupType;
+    /** Failure reason */
+    readonly failureReason?: string;
+    /** ResourceId used to identify the Elastic Volume */
+    elasticVolumeResourceId: string;
+    /** Manual backup using an already existing snapshot. This will always be CreateNewSnapshot for scheduled backups and UseExistingSnapshot/CreateNewSnapshot for manual backups */
+    snapshotUsage?: SnapshotUsage;
+    /** ResourceId used to identify the elastic snapshot resource. This is required when an existing snapshot needs to be used for creating a manual backup */
+    elasticSnapshotResourceId?: string;
+    /** ResourceId used to identify the elastic backup policy */
+    readonly elasticBackupPolicyResourceId?: string;
+    /** Specifies if the backup is for a large volume. */
+    readonly volumeSize?: VolumeSize;
+}
+export declare function elasticBackupPropertiesSerializer(item: ElasticBackupProperties): any;
+export declare function elasticBackupPropertiesDeserializer(item: any): ElasticBackupProperties;
+/** Type of backup */
+export declare enum KnownElasticBackupType {
+    /** Manual backup type */
+    Manual = "Manual",
+    /** Scheduled backup type */
+    Scheduled = "Scheduled"
+}
+/**
+ * Type of backup \
+ * {@link KnownElasticBackupType} can be used interchangeably with ElasticBackupType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Manual**: Manual backup type \
+ * **Scheduled**: Scheduled backup type
+ */
+export type ElasticBackupType = string;
+/** Snapshot usage for backup */
+export declare enum KnownSnapshotUsage {
+    /** Value indicating an existing snapshot is used */
+    UseExistingSnapshot = "UseExistingSnapshot",
+    /** Value indicating a new snapshot is created */
+    CreateNewSnapshot = "CreateNewSnapshot"
+}
+/**
+ * Snapshot usage for backup \
+ * {@link KnownSnapshotUsage} can be used interchangeably with SnapshotUsage,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **UseExistingSnapshot**: Value indicating an existing snapshot is used \
+ * **CreateNewSnapshot**: Value indicating a new snapshot is created
+ */
+export type SnapshotUsage = string;
+/** Volume size for backup */
+export declare enum KnownVolumeSize {
+    /** Value indicating backup is for a large volume */
+    Large = "Large",
+    /** Value indicating backup is not for a large volume */
+    Regular = "Regular"
+}
+/**
+ * Volume size for backup \
+ * {@link KnownVolumeSize} can be used interchangeably with VolumeSize,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Large**: Value indicating backup is for a large volume \
+ * **Regular**: Value indicating backup is not for a large volume
+ */
+export type VolumeSize = string;
+/** The response of a ElasticBackup list operation. */
+export interface _ElasticBackupListResult {
+    /** The ElasticBackup items on this page */
+    value: ElasticBackup[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _elasticBackupListResultDeserializer(item: any): _ElasticBackupListResult;
+export declare function elasticBackupArraySerializer(result: Array<ElasticBackup>): any[];
+export declare function elasticBackupArrayDeserializer(result: Array<ElasticBackup>): any[];
+/** Active Directory Configuration resource */
+export interface ActiveDirectoryConfig extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ActiveDirectoryConfigProperties;
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+}
+export declare function activeDirectoryConfigSerializer(item: ActiveDirectoryConfig): any;
+export declare function activeDirectoryConfigDeserializer(item: any): ActiveDirectoryConfig;
+/** Active Directory Configuration properties */
+export interface ActiveDirectoryConfigProperties {
+    /** A domain user account with permission to create machine accounts */
+    userName?: string;
+    /** An array of DNS server IP addresses(IPv4 only) for the Active Directory */
+    dns?: string[];
+    /** NetBIOS name of the SMB server. This name will be registered as a computer account in the AD and used to mount volumes */
+    smbServerName?: string;
+    /** The Organizational Unit (OU) within the Windows Active Directory */
+    organizationalUnit?: string;
+    /** The Active Directory site the service will limit Domain Controller discovery to */
+    site?: string;
+    /** Users to be added to the Built-in Backup Operator active directory group. A list of unique usernames without domain specifier */
+    backupOperators?: string[];
+    /** Users to be added to the Built-in Administrators active directory group. A list of unique usernames without domain specifier */
+    administrators?: string[];
+    /** Domain Users in the Active directory to be given SecurityPrivilege privilege (Needed for SMB Continuously available shares for SQL). A list of unique usernames without domain specifier */
+    securityOperators?: string[];
+    /** Status of the Active Directory */
+    readonly activeDirectoryStatus?: ActiveDirectoryStatus;
+    /** Azure lifecycle management. */
+    readonly provisioningState?: NetAppProvisioningState;
+    /** Name of the Active Directory domain */
+    domain: string;
+    /** Access password from Azure KeyVault Secrets to connect Active Directory */
+    secretPassword: SecretPassword;
+}
+export declare function activeDirectoryConfigPropertiesSerializer(item: ActiveDirectoryConfigProperties): any;
+export declare function activeDirectoryConfigPropertiesDeserializer(item: any): ActiveDirectoryConfigProperties;
+/** Status of the Active Directory */
+export declare enum KnownActiveDirectoryStatus {
+    /** Active Directory created but not in use */
+    Created = "Created",
+    /** Active Directory in use by SMB Volume */
+    InUse = "InUse",
+    /** Active Directory Deleted */
+    Deleted = "Deleted",
+    /** Error with the Active Directory */
+    Error = "Error",
+    /** Active Directory Updating */
+    Updating = "Updating"
+}
+/**
+ * Status of the Active Directory \
+ * {@link KnownActiveDirectoryStatus} can be used interchangeably with ActiveDirectoryStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Created**: Active Directory created but not in use \
+ * **InUse**: Active Directory in use by SMB Volume \
+ * **Deleted**: Active Directory Deleted \
+ * **Error**: Error with the Active Directory \
+ * **Updating**: Active Directory Updating
+ */
+export type ActiveDirectoryStatus = string;
+/** Access password from Azure KeyVault Secrets to connect Active Directory */
+export interface SecretPassword {
+    /** Properties provided by KeyVault. */
+    keyVaultProperties?: SecretPasswordKeyVaultProperties;
+    /** Identity used to authenticate to KeyVault. Applicable if keySource is 'Microsoft.KeyVault'. */
+    identity?: SecretPasswordIdentity;
+}
+export declare function secretPasswordSerializer(item: SecretPassword): any;
+export declare function secretPasswordDeserializer(item: any): SecretPassword;
+/** Properties of key vault to get the secrets for password. */
+export interface SecretPasswordKeyVaultProperties {
+    /** The Uri of KeyVault. */
+    keyVaultUri: string;
+    /** The name of KeyVault password secret. */
+    secretName: string;
+}
+export declare function secretPasswordKeyVaultPropertiesSerializer(item: SecretPasswordKeyVaultProperties): any;
+export declare function secretPasswordKeyVaultPropertiesDeserializer(item: any): SecretPasswordKeyVaultProperties;
+/** Identity used to authenticate with key vault. */
+export interface SecretPasswordIdentity {
+    /** The principal ID (object ID) of the identity used to authenticate with key vault. Read-only. */
+    readonly principalId?: string;
+    /** The Azure resource identifier of the user assigned identity used to authenticate with key vault. Applicable if identity.type has 'UserAssigned'. It should match key of identity.userAssignedIdentities. */
+    userAssignedIdentity?: string;
+}
+export declare function secretPasswordIdentitySerializer(item: SecretPasswordIdentity): any;
+export declare function secretPasswordIdentityDeserializer(item: any): SecretPasswordIdentity;
+/** The type used for update operations of the ActiveDirectoryConfig. */
+export interface ActiveDirectoryConfigUpdate {
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: ActiveDirectoryConfigUpdateProperties;
+}
+export declare function activeDirectoryConfigUpdateSerializer(item: ActiveDirectoryConfigUpdate): any;
+/** The updatable properties of the ActiveDirectoryConfig. */
+export interface ActiveDirectoryConfigUpdateProperties {
+    /** A domain user account with permission to create machine accounts */
+    userName?: string;
+    /** An array of DNS server IP addresses(IPv4 only) for the Active Directory */
+    dns?: string[];
+    /** NetBIOS name of the SMB server. This name will be registered as a computer account in the AD and used to mount volumes */
+    smbServerName?: string;
+    /** The Organizational Unit (OU) within the Windows Active Directory */
+    organizationalUnit?: string;
+    /** The Active Directory site the service will limit Domain Controller discovery to */
+    site?: string;
+    /** Users to be added to the Built-in Backup Operator active directory group. A list of unique usernames without domain specifier */
+    backupOperators?: string[];
+    /** Users to be added to the Built-in Administrators active directory group. A list of unique usernames without domain specifier */
+    administrators?: string[];
+    /** Domain Users in the Active directory to be given SecurityPrivilege privilege (Needed for SMB Continuously available shares for SQL). A list of unique usernames without domain specifier */
+    securityOperators?: string[];
+    /** Name of the Active Directory domain */
+    domain?: string;
+    /** Access password from Azure KeyVault Secrets to connect Active Directory */
+    secretPassword?: SecretPassword;
+}
+export declare function activeDirectoryConfigUpdatePropertiesSerializer(item: ActiveDirectoryConfigUpdateProperties): any;
+/** The response of a ActiveDirectoryConfig list operation. */
+export interface _ActiveDirectoryConfigListResult {
+    /** The ActiveDirectoryConfig items on this page */
+    value: ActiveDirectoryConfig[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _activeDirectoryConfigListResultDeserializer(item: any): _ActiveDirectoryConfigListResult;
+export declare function activeDirectoryConfigArraySerializer(result: Array<ActiveDirectoryConfig>): any[];
+export declare function activeDirectoryConfigArrayDeserializer(result: Array<ActiveDirectoryConfig>): any[];
+/** Information regarding regionInfo Item. */
+export interface RegionInfoResource extends ProxyResource {
+    /** regionInfo properties */
+    properties?: RegionInfo;
+}
+export declare function regionInfoResourceDeserializer(item: any): RegionInfoResource;
+/** Provides region specific information. */
+export interface RegionInfo {
+    /** Provides storage to network proximity information in the region. */
+    storageToNetworkProximity?: RegionStorageToNetworkProximity;
+    /** Provides logical availability zone mappings for the subscription for a region. */
+    availabilityZoneMappings?: RegionInfoAvailabilityZoneMappingsItem[];
+}
+export declare function regionInfoDeserializer(item: any): RegionInfo;
+/** Provides storage to network proximity information in the region. */
+export declare enum KnownRegionStorageToNetworkProximity {
+    /** Basic network connectivity. */
+    Default = "Default",
+    /** Standard T1 network connectivity. */
+    T1 = "T1",
+    /** Standard T2 network connectivity. */
+    T2 = "T2",
+    /** Standard AcrossT2 network connectivity. */
+    AcrossT2 = "AcrossT2",
+    /** Standard T1 and T2 network connectivity. */
+    T1AndT2 = "T1AndT2",
+    /** Standard T1 and AcrossT2 network connectivity. */
+    T1AndAcrossT2 = "T1AndAcrossT2",
+    /** Standard T2 and AcrossT2 network connectivity. */
+    T2AndAcrossT2 = "T2AndAcrossT2",
+    /** Standard T1, T2 and AcrossT2 network connectivity. */
+    T1AndT2AndAcrossT2 = "T1AndT2AndAcrossT2"
+}
+/**
+ * Provides storage to network proximity information in the region. \
+ * {@link KnownRegionStorageToNetworkProximity} can be used interchangeably with RegionStorageToNetworkProximity,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Default**: Basic network connectivity. \
+ * **T1**: Standard T1 network connectivity. \
+ * **T2**: Standard T2 network connectivity. \
+ * **AcrossT2**: Standard AcrossT2 network connectivity. \
+ * **T1AndT2**: Standard T1 and T2 network connectivity. \
+ * **T1AndAcrossT2**: Standard T1 and AcrossT2 network connectivity. \
+ * **T2AndAcrossT2**: Standard T2 and AcrossT2 network connectivity. \
+ * **T1AndT2AndAcrossT2**: Standard T1, T2 and AcrossT2 network connectivity.
+ */
+export type RegionStorageToNetworkProximity = string;
+export declare function regionInfoAvailabilityZoneMappingsItemArrayDeserializer(result: Array<RegionInfoAvailabilityZoneMappingsItem>): any[];
+/** model interface RegionInfoAvailabilityZoneMappingsItem */
+export interface RegionInfoAvailabilityZoneMappingsItem {
+    /** Logical availability zone. */
+    availabilityZone?: string;
+    /** Available availability zone */
+    isAvailable?: boolean;
+}
+export declare function regionInfoAvailabilityZoneMappingsItemDeserializer(item: any): RegionInfoAvailabilityZoneMappingsItem;
+/** List of regionInfo resources */
+export interface _RegionInfosList {
+    /** The RegionInfoResource items on this page */
+    value: RegionInfoResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _regionInfosListDeserializer(item: any): _RegionInfosList;
+export declare function regionInfoResourceArrayDeserializer(result: Array<RegionInfoResource>): any[];
+/** NetApp account resource */
+export interface NetAppAccount extends TrackedResource {
+    /** NetApp Account properties */
+    properties?: AccountProperties;
+    /** "If etag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.") */
+    readonly etag?: string;
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+}
+export declare function netAppAccountSerializer(item: NetAppAccount): any;
+export declare function netAppAccountDeserializer(item: any): NetAppAccount;
+/** NetApp account properties */
+export interface AccountProperties {
+    /** Azure lifecycle management */
+    readonly provisioningState?: string;
+    /** Active Directories */
+    activeDirectories?: ActiveDirectory[];
+    /** Entra ID configuration for the account. */
+    entraIdConfig?: EntraIdConfig;
+    /** Encryption settings */
+    encryption?: AccountEncryption;
+    /** Shows the status of disableShowmount for all volumes under the subscription, null equals false */
+    readonly disableShowmount?: boolean | null;
+    /** Domain for NFSv4 user ID mapping. This property will be set for all NetApp accounts in the subscription and region and only affect non ldap NFSv4 volumes. */
+    nfsV4IDDomain?: string | null;
+    /** MultiAD Status for the account */
+    readonly multiAdStatus?: MultiAdStatus;
+    /** LDAP Configuration for the account. */
+    ldapConfiguration?: LdapConfiguration;
+}
+export declare function accountPropertiesSerializer(item: AccountProperties): any;
+export declare function accountPropertiesDeserializer(item: any): AccountProperties;
+export declare function activeDirectoryArraySerializer(result: Array<ActiveDirectory>): any[];
+export declare function activeDirectoryArrayDeserializer(result: Array<ActiveDirectory>): any[];
+/** Active Directory */
+export interface ActiveDirectory {
+    /** Id of the Active Directory */
+    activeDirectoryId?: string | null;
+    /** A domain user account with permission to create machine accounts */
     username?: string;
     /** Plain text password of Active Directory domain administrator, value is masked in the response */
     password?: string;
@@ -2083,31 +4215,6 @@ export interface ActiveDirectory {
 }
 export declare function activeDirectorySerializer(item: ActiveDirectory): any;
 export declare function activeDirectoryDeserializer(item: any): ActiveDirectory;
-/** Status of the Active Directory */
-export declare enum KnownActiveDirectoryStatus {
-    /** Active Directory created but not in use */
-    Created = "Created",
-    /** Active Directory in use by SMB Volume */
-    InUse = "InUse",
-    /** Active Directory Deleted */
-    Deleted = "Deleted",
-    /** Error with the Active Directory */
-    Error = "Error",
-    /** Active Directory Updating */
-    Updating = "Updating"
-}
-/**
- * Status of the Active Directory \
- * {@link KnownActiveDirectoryStatus} can be used interchangeably with ActiveDirectoryStatus,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **Created**: Active Directory created but not in use \
- * **InUse**: Active Directory in use by SMB Volume \
- * **Deleted**: Active Directory Deleted \
- * **Error**: Error with the Active Directory \
- * **Updating**: Active Directory Updating
- */
-export type ActiveDirectoryStatus = string;
 /** LDAP search scope */
 export interface LdapSearchScopeOpt {
     /** This specifies the user DN, which overrides the base DN for user lookups. */
@@ -2119,6 +4226,30 @@ export interface LdapSearchScopeOpt {
 }
 export declare function ldapSearchScopeOptSerializer(item: LdapSearchScopeOpt): any;
 export declare function ldapSearchScopeOptDeserializer(item: any): LdapSearchScopeOpt;
+/** Entra ID configuration for the account. */
+export interface EntraIdConfig {
+    /** ApplicationId of the app created by customer to provide authentication and required API permissions for Microsoft Graph endpoint. */
+    applicationId: string;
+    /** Domain of the Active directory synced to Entra ID for hybrid identities. */
+    domain: string;
+    /** Using ServerNamePrefix, FQDN (Fully Qualified Domain Name) will be generated for SMB share, using this FQDN, SMB Share will be mounted on Entra Joined VM. */
+    serverNamePrefix: string;
+    /** Using AKV config, certificate will be fetched, which will contain private key & public certificate, that correspond to the public certificate which is uploaded on the application created by customer. This will be used further for authentication. */
+    entraIdAkvConfig?: EntraIdAkvConfig;
+}
+export declare function entraIdConfigSerializer(item: EntraIdConfig): any;
+export declare function entraIdConfigDeserializer(item: any): EntraIdConfig;
+/** Using AKV config, certificate will be fetched, which will contain private key & public certificate, that correspond to the public certificate which is uploaded on the application created by customer. This will be used further for authentication. */
+export interface EntraIdAkvConfig {
+    /** The Azure Key Vault URI where the Entra ID credentials are stored. */
+    azureKeyVaultUri: string;
+    /** The name of the certificate in Azure Key Vault. */
+    certificateName: string;
+    /** The ARM resource identifier of the user assigned identity used to authenticate with key vault. */
+    userAssignedIdentity?: string;
+}
+export declare function entraIdAkvConfigSerializer(item: EntraIdAkvConfig): any;
+export declare function entraIdAkvConfigDeserializer(item: any): EntraIdAkvConfig;
 /** Encryption settings */
 export interface AccountEncryption {
     /** The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.NetApp, Microsoft.KeyVault */
@@ -2130,22 +4261,6 @@ export interface AccountEncryption {
 }
 export declare function accountEncryptionSerializer(item: AccountEncryption): any;
 export declare function accountEncryptionDeserializer(item: any): AccountEncryption;
-/** The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.NetApp, Microsoft.KeyVault */
-export declare enum KnownKeySource {
-    /** Microsoft-managed key encryption */
-    MicrosoftNetApp = "Microsoft.NetApp",
-    /** Customer-managed key encryption */
-    MicrosoftKeyVault = "Microsoft.KeyVault"
-}
-/**
- * The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.NetApp, Microsoft.KeyVault \
- * {@link KnownKeySource} can be used interchangeably with KeySource,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **Microsoft.NetApp**: Microsoft-managed key encryption \
- * **Microsoft.KeyVault**: Customer-managed key encryption
- */
-export type KeySource = string;
 /** Properties of key vault. */
 export interface KeyVaultProperties {
     /** UUID v4 used to identify the Azure Key Vault configuration */
@@ -2213,50 +4328,21 @@ export declare enum KnownMultiAdStatus {
  * **Enabled**: Account is MultiAD enabled
  */
 export type MultiAdStatus = string;
-/** Managed service identity (system assigned and/or user assigned identities) */
-export interface ManagedServiceIdentity {
-    /** The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity. */
-    readonly principalId?: string;
-    /** The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity. */
-    readonly tenantId?: string;
-    /** The type of managed identity assigned to this resource. */
-    type: ManagedServiceIdentityType;
-    /** The identities assigned to this resource by the user. */
-    userAssignedIdentities?: Record<string, UserAssignedIdentity | null>;
-}
-export declare function managedServiceIdentitySerializer(item: ManagedServiceIdentity): any;
-export declare function managedServiceIdentityDeserializer(item: any): ManagedServiceIdentity;
-/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
-export declare enum KnownManagedServiceIdentityType {
-    /** No managed identity. */
-    None = "None",
-    /** System assigned managed identity. */
-    SystemAssigned = "SystemAssigned",
-    /** User assigned managed identity. */
-    UserAssigned = "UserAssigned",
-    /** System and user assigned managed identity. */
-    SystemAssignedUserAssigned = "SystemAssigned,UserAssigned"
-}
-/**
- * Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). \
- * {@link KnownManagedServiceIdentityType} can be used interchangeably with ManagedServiceIdentityType,
- *  this enum contains the known values that the service supports.
- * ### Known values supported by the service
- * **None**: No managed identity. \
- * **SystemAssigned**: System assigned managed identity. \
- * **UserAssigned**: User assigned managed identity. \
- * **SystemAssigned,UserAssigned**: System and user assigned managed identity.
- */
-export type ManagedServiceIdentityType = string;
-/** User assigned identity properties */
-export interface UserAssignedIdentity {
-    /** The principal ID of the assigned identity. */
-    readonly principalId?: string;
-    /** The client ID of the assigned identity. */
-    readonly clientId?: string;
+/** LDAP configuration */
+export interface LdapConfiguration {
+    /** Name of the LDAP configuration domain */
+    domain?: string;
+    /** List of LDAP server IP addresses (IPv4 only) for the LDAP domain. */
+    ldapServers?: string[];
+    /** Specifies whether or not the LDAP traffic needs to be secured via TLS. */
+    ldapOverTLS?: boolean;
+    /** When LDAP over SSL/TLS is enabled, the LDAP client is required to have base64 encoded ldap servers CA certificate. */
+    serverCACertificate?: string;
+    /** The CN host name used while generating the certificate, LDAP Over TLS requires the CN host name to create DNS host entry. */
+    certificateCNHost?: string | null;
 }
-export declare function userAssignedIdentitySerializer(item: UserAssignedIdentity): any;
-export declare function userAssignedIdentityDeserializer(item: any): UserAssignedIdentity;
+export declare function ldapConfigurationSerializer(item: LdapConfiguration): any;
+export declare function ldapConfigurationDeserializer(item: any): LdapConfiguration;
 /** NetApp account patch resource */
 export interface NetAppAccountPatch {
     /** Resource location */
@@ -2270,11 +4356,63 @@ export interface NetAppAccountPatch {
     /** Resource tags */
     tags?: Record<string, string>;
     /** NetApp Account properties */
-    properties?: AccountProperties;
+    properties?: AccountPropertiesPatch;
     /** The identity used for the resource. */
     identity?: ManagedServiceIdentity;
 }
 export declare function netAppAccountPatchSerializer(item: NetAppAccountPatch): any;
+/** NetApp account properties for PATCH operations */
+export interface AccountPropertiesPatch {
+    /** Active Directories */
+    activeDirectories?: ActiveDirectory[];
+    /** Entra ID configuration for the account. */
+    entraIdConfig?: EntraIdConfigPatch;
+    /** Encryption settings */
+    encryption?: AccountEncryption;
+    /** Domain for NFSv4 user ID mapping. This property will be set for all NetApp accounts in the subscription and region and only affect non ldap NFSv4 volumes. */
+    nfsV4IDDomain?: string | null;
+    /** MultiAD Status for the account */
+    multiAdStatus?: MultiAdStatus;
+    /** LDAP Configuration for the account. */
+    ldapConfiguration?: LdapConfigurationPatch;
+}
+export declare function accountPropertiesPatchSerializer(item: AccountPropertiesPatch): any;
+/** Entra ID Patch configuration for the account. */
+export interface EntraIdConfigPatch {
+    /** ApplicationId of the app created by customer to provide authentication and required API permissions for Microsoft Graph endpoint. */
+    applicationId?: string;
+    /** Domain of the Active directory synced to Entra ID for hybrid identities. */
+    domain?: string;
+    /** Using ServerNamePrefix, FQDN (Fully Qualified Domain Name) will be generated for SMB share, using this FQDN, SMB Share will be mounted on Entra Joined VM. */
+    serverNamePrefix?: string;
+    /** Using AKV config, certificate will be fetched, which will contain private key & public certificate, that correspond to the public certificate which is uploaded on the application created by customer. This will be used further for authentication. */
+    entraIdAkvConfig?: EntraIdAkvConfigPatch;
+}
+export declare function entraIdConfigPatchSerializer(item: EntraIdConfigPatch): any;
+/** Using AKV config, certificate will be fetched, which will contain private key & public certificate, that correspond to the public certificate which is uploaded on the application created by customer. This will be used further for authentication. */
+export interface EntraIdAkvConfigPatch {
+    /** The Azure Key Vault URI where the Entra ID credentials are stored. */
+    azureKeyVaultUri?: string;
+    /** The name of the certificate in Azure Key Vault. */
+    certificateName?: string;
+    /** The ARM resource identifier of the user assigned identity used to authenticate with key vault. */
+    userAssignedIdentity?: string;
+}
+export declare function entraIdAkvConfigPatchSerializer(item: EntraIdAkvConfigPatch): any;
+/** LDAP configuration for PATCH operations (no default values) */
+export interface LdapConfigurationPatch {
+    /** Name of the LDAP configuration domain */
+    domain?: string;
+    /** List of LDAP server IP addresses (IPv4 only) for the LDAP domain. */
+    ldapServers?: string[];
+    /** Specifies whether or not the LDAP traffic needs to be secured via TLS. */
+    ldapOverTLS?: boolean;
+    /** When LDAP over SSL/TLS is enabled, the LDAP client is required to have base64 encoded ldap servers CA certificate. */
+    serverCACertificate?: string;
+    /** The CN host name used while generating the certificate, LDAP Over TLS requires the CN host name to create DNS host entry. */
+    certificateCNHost?: string | null;
+}
+export declare function ldapConfigurationPatchSerializer(item: LdapConfigurationPatch): any;
 /** List of NetApp account resources */
 export interface _NetAppAccountList {
     /** The NetAppAccount items on this page */
@@ -2353,7 +4491,7 @@ export declare function capacityPoolDeserializer(item: any): CapacityPool;
 export interface PoolProperties {
     /** UUID v4 used to identify the Pool */
     readonly poolId?: string;
-    /** Provisioned size of the pool (in bytes). Allowed values are in 1TiB chunks (value must be multiple of 1099511627776). */
+    /** Provisioned size of the pool (in bytes). Allowed values are 512GiB (549755813888 bytes) or in 1TiB chunks (value must be multiple of 1099511627776). */
     size: number;
     /** The service level of the file system */
     serviceLevel: ServiceLevel;
@@ -2424,7 +4562,7 @@ export interface CapacityPoolPatch {
 export declare function capacityPoolPatchSerializer(item: CapacityPoolPatch): any;
 /** Patchable pool properties */
 export interface PoolPatchProperties {
-    /** Provisioned size of the pool (in bytes). Allowed values are in 1TiB chunks (value must be multiple of 1099511627776). */
+    /** Provisioned size of the pool (in bytes). Allowed values are 512GiB (549755813888 bytes) or in 1TiB chunks (value must be multiple of 1099511627776). */
     size?: number;
     /** The qos type of the pool */
     qosType?: QosType;
@@ -2759,6 +4897,8 @@ export declare enum KnownVersions {
     /** The 2025-09-01 API version. */
     V20250901 = "2025-09-01",
     /** The 2025-12-01 API version. */
-    V20251201 = "2025-12-01"
+    V20251201 = "2025-12-01",
+    /** The 2025-12-15-preview API version. */
+    V20251215Preview = "2025-12-15-preview"
 }
 //# sourceMappingURL=models.d.ts.map